diff --git a/course/classes/course_format.php b/course/classes/course_format.php
index debd894f51b..f55b3c97163 100644
--- a/course/classes/course_format.php
+++ b/course/classes/course_format.php
@@ -967,7 +967,6 @@ abstract class course_format {
     public function editsection_form($action, $customdata = array()) {
         global $CFG;
         require_once($CFG->dirroot. '/course/editsection_form.php');
-        $context = context_course::instance($this->courseid);
         if (!array_key_exists('course', $customdata)) {
             $customdata['course'] = $this->get_course();
         }
@@ -1091,6 +1090,18 @@ abstract class course_format {
         return ($sectionnum && ($course = $this->get_course()) && $course->marker == $sectionnum);
     }
 
+    /**
+     * return true if the course editor must be displayed.
+     *
+     * @return bool true if edit controls must be displayed
+     */
+    public function show_editor(): bool {
+        global $PAGE;
+        $course = $this->get_course();
+        $coursecontext = context_course::instance($course->id);
+        return $PAGE->user_is_editing() && has_capability('moodle/course:update', $coursecontext);
+    }
+
     /**
      * Allows to specify for modinfo that section is not available even when it is visible and conditionally available.
      *
@@ -1387,16 +1398,13 @@ abstract class course_format {
         }
 
         // Load the cmlist output.
-        $cmitemclass = $this->get_output_classname('section_format\\cmitem');
         $renderer = $this->get_renderer($PAGE);
 
         $coursesections = $modinfo->sections;
         if (array_key_exists($section->section, $coursesections)) {
-            $completioninfo = new completion_info($course);
             foreach ($coursesections[$section->section] as $cmid) {
                 $cm = $modinfo->get_cm($cmid);
-                $cmitem = new $cmitemclass($this, $section, $cm);
-                $modules[] = $renderer->render($cmitem);
+                $modules[] = $renderer->course_section_updated_cm_item($this, $section, $cm);
             }
         }
 
diff --git a/course/classes/output/cm_format.php b/course/classes/output/cm_format.php
new file mode 100644
index 00000000000..1ae369554b4
--- /dev/null
+++ b/course/classes/output/cm_format.php
@@ -0,0 +1,134 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default activity list from a section.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output;
+
+use core_course\course_format;
+use section_info;
+use completion_info;
+use renderable;
+use templatable;
+use cm_info;
+use stdClass;
+
+/**
+ * Base class to render a course module inside a course format.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cm_format implements renderable, templatable {
+
+    /** @var course_format the course format */
+    protected $format;
+
+    /** @var section_info the section object */
+    private $section;
+
+    /** @var cm_info the course module instance */
+    protected $mod;
+
+    /** @var array optional display options */
+    protected $displayoptions;
+
+    /** @var completion_info the course completion */
+    protected $completioninfo;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     * @param completion_info $completioninfo the course completion info
+     * @param cm_info $mod the course module ionfo
+     * @param array $displayoptions optional extra display options
+     */
+    public function __construct(course_format $format, section_info $section, completion_info $completioninfo,
+                cm_info $mod, array $displayoptions = []) {
+
+        $this->format = $format;
+        $this->section = $section;
+        $this->completioninfo = $completioninfo;
+        $this->mod = $mod;
+        $this->displayoptions = $displayoptions;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+        $format = $this->format;
+        $course = $format->get_course();
+        $mod = $this->mod;
+        $displayoptions = $this->displayoptions;
+
+        $data = (object)[
+            'cmname' => $output->course_section_cm_name($mod, $displayoptions),
+            'afterlink' => $mod->afterlink,
+            'altcontent' => $output->course_section_cm_text($mod, $displayoptions),
+            'availability' => $output->course_section_cm_availability($mod, $displayoptions),
+            'url' => $mod->url,
+            'completion' => $output->course_section_cm_completion(
+                $course, $this->completioninfo, $mod, $displayoptions
+            ),
+        ];
+
+        if (!empty($mod->indent)) {
+            $data->indent = $mod->indent;
+            if ($mod->indent > 15) {
+                $data->hugeindent = true;
+            }
+        }
+
+        if (!empty($data->cmname)) {
+            $data->hasname = true;
+        }
+        if (!empty($data->url)) {
+            $data->hasurl = true;
+        }
+
+        $returnsection = $format->get_section_number();
+        $data->extras = [];
+        if ($format->show_editor()) {
+            // Edit actions.
+            $editactions = course_get_cm_edit_actions($mod, $mod->indent, $returnsection);
+            $data->extras[] = $output->course_section_cm_edit_actions($editactions, $mod, $displayoptions);
+            if (!empty($mod->afterediticons)) {
+                $data->extras[] = $mod->afterediticons;
+            }
+            // Move and select options.
+            $data->moveicon = course_get_cm_move($mod, $returnsection);
+        }
+
+        if (!empty($data->completion) || !empty($data->extras)) {
+            $data->hasextras = true;
+        }
+
+        return $data;
+    }
+}
diff --git a/course/classes/output/course_format.php b/course/classes/output/course_format.php
new file mode 100644
index 00000000000..dc55b011ed9
--- /dev/null
+++ b/course/classes/output/course_format.php
@@ -0,0 +1,185 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the main course format out class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output;
+
+use core_course\course_format as course_format_base;
+use course_modinfo;
+use renderable;
+use templatable;
+use stdClass;
+
+/**
+ * Base class to render a course format.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class course_format implements renderable, templatable {
+
+    /** @var core_course\course_format the course format class */
+    protected $format;
+
+    /** @var string the section format class */
+    protected $sectionclass;
+
+    /** @var string the add section output class name */
+    protected $addsectionclass;
+
+    /** @var string section navigation class name */
+    protected $sectionnavigationclass;
+
+    /** @var string section selector class name */
+    protected $sectionselectorclass;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format_base $format the coruse format
+     */
+    public function __construct(course_format_base $format) {
+        $this->format = $format;
+
+        // Load output classes names from format.
+        $this->sectionclass = $format->get_output_classname('section_format');
+        $this->addsectionclass = $format->get_output_classname('course_format\\addsection');
+        $this->sectionnavigationclass = $format->get_output_classname('course_format\\sectionnavigation');
+        $this->sectionselectorclass = $format->get_output_classname('course_format\\sectionselector');
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template (core/inplace_editable).
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output) {
+        $format = $this->format;
+
+        $addsection = new $this->addsectionclass($format);
+
+        // Most formats uses section 0 as a separate section so we remove from the list.
+        $sections = $this->export_sections($output);
+        $initialsection = '';
+        if (!empty($sections)) {
+            $initialsection = array_shift($sections);
+        }
+
+        $data = (object)[
+            'title' => $format->page_title(), // This method should be in the course_format class.
+            'initialsection' => $initialsection,
+            'sections' => $sections,
+            'numsections' => $addsection->export_for_template($output),
+            'format' => $format->get_format(),
+        ];
+
+        // The single section format has extra navigation.
+        $singlesection = $this->format->get_section_number();
+        if ($singlesection) {
+            $sectionnavigation = new $this->sectionnavigationclass($format, $singlesection);
+            $data->sectionnavigation = $sectionnavigation->export_for_template($output);
+
+            $sectionselector = new $this->sectionselectorclass($format, $sectionnavigation);
+            $data->sectionselector = $sectionselector->export_for_template($output);
+
+            $data->hasnavigation = true;
+            $data->singlesection = array_shift($data->sections);
+        }
+
+        return $data;
+    }
+
+    /**
+     * Export sections array data.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    protected function export_sections(\renderer_base $output): array {
+
+        $format = $this->format;
+        $course = $format->get_course();
+        $modinfo = $this->format->get_modinfo();
+
+        // Generate section list.
+        $sections = [];
+        $stealthsections = [];
+        $numsections = $format->get_last_section_number();
+        foreach ($this->get_sections_to_display($modinfo) as $sectionnum => $thissection) {
+            // The course/view.php check the section existence but the output can be called
+            // from other parts so we need to check it.
+            if (!$thissection) {
+                print_error('unknowncoursesection', 'error', course_get_url($course), format_string($course->fullname));
+            }
+
+            $section = new $this->sectionclass($format, $thissection);
+
+            if ($sectionnum > $numsections) {
+                // Activities inside this section are 'orphaned', this section will be printed as 'stealth' below.
+                if (!empty($modinfo->sections[$sectionnum])) {
+                    $stealthsections[] = $section->export_for_template($output);
+                }
+                continue;
+            }
+
+            // Show the section if the user is permitted to access it, OR if it's not available
+            // but there is some available info text which explains the reason & should display,
+            // OR it is hidden but the course has a setting to display hidden sections as unavilable.
+            $showsection = $thissection->uservisible ||
+                    ($thissection->visible && !$thissection->available && !empty($thissection->availableinfo)) ||
+                    (!$thissection->visible && !$course->hiddensections);
+            if (!$showsection) {
+                continue;
+            }
+
+            $sections[] = $section->export_for_template($output);
+        }
+        if (!empty($stealthsections)) {
+            $sections = array_merge($sections, $stealthsections);
+        }
+        return $sections;
+    }
+
+    /**
+     * Return an array of sections to display.
+     *
+     * This method is used to differentiate between display a specific section
+     * or a list of them.
+     *
+     * @param course_modinfo $modinfo the current course modinfo object
+     * @return section_info[] an array of section_info to display
+     */
+    private function get_sections_to_display(course_modinfo $modinfo): array {
+        $singlesection = $this->format->get_section_number();
+        if ($singlesection) {
+            return [
+                $modinfo->get_section_info(0),
+                $modinfo->get_section_info($singlesection),
+            ];
+        }
+
+        return $modinfo->get_section_info_all();
+    }
+}
diff --git a/course/classes/output/course_format/addsection.php b/course/classes/output/course_format/addsection.php
new file mode 100644
index 00000000000..2f1d9a3de75
--- /dev/null
+++ b/course/classes/output/course_format/addsection.php
@@ -0,0 +1,131 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section course format output class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\course_format;
+
+use core_course\course_format;
+use renderable;
+use templatable;
+use moodle_url;
+use stdClass;
+
+/**
+ * Base class to render a course add section buttons.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class addsection implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     */
+    public function __construct(course_format $format) {
+        $this->format = $format;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        $format = $this->format;
+        $course = $format->get_course();
+        $options = $format->get_format_options();
+
+        $lastsection = $format->get_last_section_number();
+        $maxsections = $format->get_max_sections();
+
+        $data = new stdClass();
+
+        // If no editor must be displayed, just retun an empty structure.
+        if (!$format->show_editor()) {
+            return $data;
+        }
+
+        $supportsnumsections = array_key_exists('numsections', $options);
+        if ($supportsnumsections) {
+            // Current course format has 'numsections' option, which is very confusing and we suggest course format
+            // developers to get rid of it (see MDL-57769 on how to do it).
+
+            if ($lastsection < $maxsections) {
+                $data->increase = (object) [
+                    'url' => new moodle_url(
+                        '/course/changenumsections.php',
+                        ['courseid' => $course->id, 'increase' => true, 'sesskey' => sesskey()]
+                    ),
+                ];
+            }
+
+            if ($course->numsections > 0) {
+                $data->decrease = (object) [
+                    'url' => new moodle_url(
+                        '/course/changenumsections.php',
+                        ['courseid' => $course->id, 'increase' => false, 'sesskey' => sesskey()]
+                    ),
+                ];
+            }
+
+        } else if (course_get_format($course)->uses_sections() && $lastsection < $maxsections) {
+            // Current course format does not have 'numsections' option but it has multiple sections suppport.
+            // Display the "Add section" link that will insert a section in the end.
+            // Note to course format developers: inserting sections in the other positions should check both
+            // capabilities 'moodle/course:update' and 'moodle/course:movesections'.
+
+            if (get_string_manager()->string_exists('addsections', 'format_'.$course->format)) {
+                $addstring = get_string('addsections', 'format_'.$course->format);
+            } else {
+                $addstring = get_string('addsections');
+            }
+
+            $params = ['courseid' => $course->id, 'insertsection' => 0, 'sesskey' => sesskey()];
+
+            $singlesection = $this->format->get_section_number();
+            if ($singlesection) {
+                $params['sectionreturn'] = $singlesection;
+            }
+
+            $data->addsections = (object) [
+                'url' => new moodle_url('/course/changenumsections.php', $params),
+                'title' => $addstring,
+                'newsection' => $maxsections - $lastsection,
+            ];
+        }
+
+        if (count((array)$data)) {
+            $data->showaddsection = true;
+        }
+
+        return $data;
+    }
+}
diff --git a/course/classes/output/course_format/frontpagesection.php b/course/classes/output/course_format/frontpagesection.php
new file mode 100644
index 00000000000..3e91b9e5229
--- /dev/null
+++ b/course/classes/output/course_format/frontpagesection.php
@@ -0,0 +1,101 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default frontpage section displayer.
+ *
+ * The frontpage has a different wat of rendering the main topic.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\course_format;
+
+use core_course\course_format;
+use renderable;
+use templatable;
+use section_info;
+use context_course;
+use moodle_url;
+use stdClass;
+
+/**
+ * Represents the frontpage section 1.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class frontpagesection implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the course section class */
+    protected $section;
+
+    /** @var string the section output class name */
+    protected $sectionclass;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     */
+    public function __construct(course_format $format, section_info $section) {
+        $this->format = $format;
+        $this->section = $section;
+
+        // Get the necessary classes.
+        $this->sectionclass = $format->get_output_classname('section_format');
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+        global $USER;
+
+        $format = $this->format;
+        $course = $format->get_course();
+        $context = context_course::instance($course->id);
+        $section = $this->section;
+
+        $sectionoutput = new $this->sectionclass($format, $section);
+        $sectionoutput->hide_controls();
+
+        if (trim($section->name) == '') {
+            $sectionoutput->hide_title();
+        }
+
+        $data = (object)[
+            'sections' => [$sectionoutput->export_for_template($output)],
+        ];
+
+        if ($format->show_editor() && has_capability('moodle/course:update', $context)) {
+            $data->showsettings = true;
+            $data->settingsurl = new moodle_url('/course/editsection.php', ['id' => $section->id]);
+        }
+
+        return $data;
+    }
+}
diff --git a/course/classes/output/course_format/sectionnavigation.php b/course/classes/output/course_format/sectionnavigation.php
new file mode 100644
index 00000000000..9ded0563fd4
--- /dev/null
+++ b/course/classes/output/course_format/sectionnavigation.php
@@ -0,0 +1,123 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section navigation output class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\course_format;
+
+use core_course\course_format;
+use renderable;
+use templatable;
+use context_course;
+use stdClass;
+
+/**
+ * Base class to render a course add section navigation.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class sectionnavigation implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var int the course displayed section */
+    protected $sectionno;
+
+    /** @var stdClass the calculated data to prevent calculations when rendered several times */
+    private $data = null;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param int $sectionno the section number
+     */
+    public function __construct(course_format $format, int $sectionno) {
+        $this->format = $format;
+        $this->sectionno = $sectionno;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+        global $USER;
+
+        if ($this->data !== null) {
+            return $this->data;
+        }
+
+        $format = $this->format;
+        $course = $format->get_course();
+        $context = context_course::instance($course->id);
+
+        $modinfo = $this->format->get_modinfo();
+        $sections = $modinfo->get_section_info_all();
+
+        // FIXME: This is really evil and should by using the navigation API.
+        $canviewhidden = has_capability('moodle/course:viewhiddensections', $context, $USER) || !$course->hiddensections;
+
+        $data = (object)[
+            'previousurl' => '',
+            'nexturl' => '',
+            'larrow' => $output->larrow(),
+            'rarrow' => $output->rarrow(),
+            'currentsection' => $this->sectionno,
+        ];
+
+        $back = $this->sectionno - 1;
+        while ($back > 0 and empty($data->previousurl)) {
+            if ($canviewhidden || $sections[$back]->uservisible) {
+                if (!$sections[$back]->visible) {
+                    $data->previoushidden = true;
+                }
+                $data->previousname = get_section_name($course, $sections[$back]);
+                $data->previousurl = course_get_url($course, $back);
+                $data->hasprevious = true;
+            }
+            $back--;
+        }
+
+        $forward = $this->sectionno + 1;
+        $numsections = course_get_format($course)->get_last_section_number();
+        while ($forward <= $numsections and empty($data->nexturl)) {
+            if ($canviewhidden || $sections[$forward]->uservisible) {
+                if (!$sections[$forward]->visible) {
+                    $data->nexthidden = true;
+                }
+                $data->nextname = get_section_name($course, $sections[$forward]);
+                $data->nexturl = course_get_url($course, $forward);
+                $data->hasnext = true;
+            }
+            $forward++;
+        }
+
+        $this->data = $data;
+        return $data;
+    }
+}
diff --git a/course/classes/output/course_format/sectionselector.php b/course/classes/output/course_format/sectionselector.php
new file mode 100644
index 00000000000..0eb5b548e09
--- /dev/null
+++ b/course/classes/output/course_format/sectionselector.php
@@ -0,0 +1,100 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section selector.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\course_format;
+
+use core_course\course_format;
+use renderable;
+use templatable;
+use url_select;
+use stdClass;
+
+/**
+ * Represents the section selector.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class sectionselector implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var sectionnavigation the main section navigation class */
+    protected $navigation;
+
+    /**
+     * Constructor.
+     *
+     * In the current imeplementaiton the seciton selector is almost a variation of the section navigator
+     * but in the 4.0 this selector will be a kind of dropdown menu. When this happens the construct params
+     * will change.
+     *
+     * @param course_format $format the course format
+     * @param sectionnavigation $navigation the current section navigation
+     */
+    public function __construct(course_format $format, sectionnavigation $navigation) {
+        $this->format = $format;
+        $this->navigation = $navigation;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        $format = $this->format;
+        $course = $format->get_course();
+
+        $modinfo = $this->format->get_modinfo();
+
+        $data = $this->navigation->export_for_template($output);
+
+        // Add the section selector.
+        $sectionmenu = [];
+        $sectionmenu[course_get_url($course)->out(false)] = get_string('maincoursepage');
+        $section = 1;
+        $numsections = $format->get_last_section_number();
+        while ($section <= $numsections) {
+            $thissection = $modinfo->get_section_info($section);
+            $showsection = $thissection->uservisible || !$course->hiddensections;
+            $url = course_get_url($course, $section);
+            if ($showsection && $url && $section != $data->currentsection) {
+                $sectionmenu[$url->out(false)] = get_section_name($course, $section);
+            }
+            $section++;
+        }
+
+        $select = new url_select($sectionmenu, '', ['' => get_string('jumpto')]);
+        $select->class = 'jumpmenu';
+        $select->formid = 'sectionmenu';
+
+        $data->selector = $output->render($select);
+        return $data;
+    }
+}
diff --git a/course/classes/output/section_format.php b/course/classes/output/section_format.php
new file mode 100644
index 00000000000..ffd9d102ac2
--- /dev/null
+++ b/course/classes/output/section_format.php
@@ -0,0 +1,211 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section course format output class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output;
+
+use core_course\course_format;
+use completion_info;
+use renderable;
+use templatable;
+use section_info;
+use stdClass;
+
+/**
+ * Base class to render a course section.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class section_format implements renderable, templatable {
+
+    /** @var course_format the course format */
+    protected $format;
+
+    /** @var section_info the section info */
+    protected $thissection;
+
+    /** @var section header output class */
+    protected $headerclass;
+
+    /** @var cm list output class */
+    protected $cmlistclass;
+
+    /** @var section summary output class */
+    protected $summaryclass;
+
+    /** @var activities summary output class */
+    protected $cmsummaryclass;
+
+    /** @var section control menu output class */
+    protected $controlclass;
+
+    /** @var section availability output class */
+    protected $availabilityclass;
+
+    /** @var optional move here output class */
+    protected $movehereclass;
+
+    /** @var bool if the title is hidden for some reason */
+    protected $hidetitle = false;
+
+    /** @var bool if the title is hidden for some reason */
+    protected $hidecontrols = false;
+
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $thissection the section info
+     */
+    public function __construct(course_format $format, section_info $thissection) {
+        $this->format = $format;
+        $this->thissection = $thissection;
+
+        // Load output classes names from format.
+        $this->headerclass = $format->get_output_classname('section_format\\header');
+        $this->cmlistclass = $format->get_output_classname('section_format\\cmlist');
+        $this->summaryclass = $format->get_output_classname('section_format\\summary');
+        $this->cmsummaryclass = $format->get_output_classname('section_format\\cmsummary');
+        $this->controlmenuclass = $format->get_output_classname('section_format\\controlmenu');
+        $this->availabilityclass = $format->get_output_classname('section_format\\availability');
+        $this->movehereclass = $format->get_output_classname('section_format\\movehere');
+    }
+
+    /**
+     * Hide the section title.
+     *
+     * This is used on blocks or in the home page where an isolated section is displayed.
+     */
+    public function hide_title(): void {
+        $this->hidetitle = true;
+    }
+
+    /**
+     * Hide the section controls.
+     *
+     * This is used on blocks or in the home page where an isolated section is displayed.
+     */
+    public function hide_controls(): void {
+        $this->hidecontrols = true;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdClass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        $format = $this->format;
+        $course = $format->get_course();
+        $thissection = $this->thissection;
+        $singlesection = $format->get_section_number();
+
+        $summary = new $this->summaryclass($format, $thissection);
+        $availability = new $this->availabilityclass($format, $thissection);
+
+        $data = (object)[
+            'num' => $thissection->section ?? '0',
+            'id' => $thissection->id,
+            'sectionreturnid' => $singlesection,
+            'summary' => $summary->export_for_template($output),
+            'availability' => $availability->export_for_template($output),
+        ];
+
+        // Check if it is a stealth sections (orphaned).
+        if ($thissection->section > $format->get_last_section_number()) {
+            $data->isstealth = true;
+            $data->ishidden = true;
+        }
+
+        if ($format->show_editor()) {
+            if (empty($this->hidecontrols)) {
+                $controlmenu = new $this->controlmenuclass($format, $thissection);
+                $data->controlmenu = $controlmenu->export_for_template($output);
+            }
+            if (empty($data->isstealth)) {
+                $data->cmcontrols = $output->course_section_add_cm_control($course, $thissection->section, 0);
+            }
+        }
+
+        if ($thissection->section == 0) {
+            // Section zero is always visible only as a cmlist.
+            $cmlist = new $this->cmlistclass($format, $thissection);
+            $data->cmlist = $cmlist->export_for_template($output);
+
+            // Section 0 could have a completion help icon.
+            $completioninfo = new completion_info($course);
+            $data->completioninfo = $completioninfo->display_help_icon();
+
+            return $data;
+        }
+
+        // When a section is displayed alone the title goes over the section, not inside it.
+        $header = new $this->headerclass($format, $thissection);
+
+        if ($thissection->section == $singlesection) {
+            if (empty($this->hidetitle)) {
+                $data->singleheader = $header->export_for_template($output);
+            }
+        } else {
+            if (empty($this->hidetitle)) {
+                $data->header = $header->export_for_template($output);
+            }
+
+            // Add activities summary if necessary.
+            if (!$format->show_editor() && $course->coursedisplay == COURSE_DISPLAY_MULTIPAGE) {
+                $cmsummary = new $this->cmsummaryclass($format, $thissection);
+                $data->cmsummary = $cmsummary->export_for_template($output);
+
+                $data->onlysummary = true;
+                if (!$format->is_section_current($thissection)) {
+                    // In multipage, only the current section (and the section zero) has elements.
+                    return $data;
+                }
+            }
+        }
+
+        // Add the cm list.
+        if ($thissection->uservisible) {
+            $cmlist = new $this->cmlistclass($format, $thissection);
+            $data->cmlist = $cmlist->export_for_template($output);
+        }
+
+        if (!$thissection->visible) {
+            $data->ishidden = true;
+        }
+        if ($format->is_section_current($thissection)) {
+            $data->iscurrent = true;
+            $data->currentlink = get_accesshide(
+                get_string('currentsection', 'format_'.$format->get_format())
+            );
+        }
+
+        return $data;
+    }
+}
+
diff --git a/course/classes/output/section_format/availability.php b/course/classes/output/section_format/availability.php
new file mode 100644
index 00000000000..bd10d886079
--- /dev/null
+++ b/course/classes/output/section_format/availability.php
@@ -0,0 +1,123 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section availability output class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use renderable;
+use templatable;
+use core_availability\info_section;
+use core_availability\info;
+use context_course;
+use stdClass;
+
+/**
+ * Base class to render section availability.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class availability implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the section object */
+    protected $section;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     */
+    public function __construct(course_format $format, section_info $section) {
+        $this->format = $format;
+        $this->section = $section;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * If section is not visible, display the message about that ('Not available
+     * until...', that sort of thing). Otherwise, returns blank.
+     *
+     * For users with the ability to view hidden sections, it shows the
+     * information even though you can view the section and also may include
+     * slightly fuller information (so that teachers can tell when sections
+     * are going to be unavailable etc). This logic is the same as for
+     * activities.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return stdclass data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+        global $CFG, $USER;
+
+        $format = $this->format;
+        $section = $this->section;
+        $course = $format->get_course();
+        $context = context_course::instance($section->course);
+
+        $canviewhidden = has_capability('moodle/course:viewhiddensections', $context, $USER);
+
+        $info = '';
+        if (!$section->visible) {
+            if ($canviewhidden) {
+                $info = $output->availability_info(get_string('hiddenfromstudents'), 'ishidden');
+            } else {
+                // We are here because of the setting "Hidden sections are shown in collapsed form".
+                // Student can not see the section contents but can see its name.
+                $info = $output->availability_info(get_string('notavailable'), 'ishidden');
+            }
+        } else if (!$section->uservisible) {
+            if ($section->availableinfo) {
+                // Note: We only get to this function if availableinfo is non-empty,
+                // so there is definitely something to print.
+                $formattedinfo = info::format_info($section->availableinfo, $section->course);
+                $info = $output->availability_info($formattedinfo, 'isrestricted');
+            }
+        } else if ($canviewhidden && !empty($CFG->enableavailability)) {
+            // Check if there is an availability restriction.
+            $ci = new info_section($section);
+            $fullinfo = $ci->get_full_information();
+            if ($fullinfo) {
+                $formattedinfo = info::format_info($fullinfo, $section->course);
+                $info = $output->availability_info($formattedinfo, 'isrestricted isfullinfo');
+            }
+        }
+
+        $data = (object)[
+            'info' => $info,
+        ];
+
+        if (!empty($info)) {
+            $data->hasavailability = true;
+        }
+
+        return $data;
+    }
+}
diff --git a/course/classes/output/section_format/cmitem.php b/course/classes/output/section_format/cmitem.php
new file mode 100644
index 00000000000..6a6bc5eb3a7
--- /dev/null
+++ b/course/classes/output/section_format/cmitem.php
@@ -0,0 +1,101 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default activity item from a section.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use completion_info;
+use renderable;
+use templatable;
+use cm_info;
+use stdClass;
+
+/**
+ * Base class to render a section activity in the activities list.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cmitem implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_format the course section class */
+    protected $section;
+
+    /** @var cm_info the course module to display */
+    protected $mod;
+
+    /** @var array optional display options */
+    protected $displayoptions;
+
+    /** @var string the cm output class name */
+    protected $cmclass;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     * @param cm_info $mod the course module ionfo
+     * @param array $displayoptions optional extra display options
+     */
+    public function __construct(course_format $format, section_info $section, cm_info $mod, array $displayoptions = []) {
+        $this->format = $format;
+        $this->section = $section;
+        $this->mod = $mod;
+        $this->displayoptions = $displayoptions;
+
+        // Get the necessary classes.
+        $this->cmclass = $format->get_output_classname('cm_format');
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+        $format = $this->format;
+        $course = $format->get_course();
+        $completioninfo = new completion_info($course);
+        $mod = $this->mod;
+
+        $data = new stdClass();
+        $data->cms = [];
+
+        $item = new $this->cmclass($format, $this->section, $completioninfo, $mod, $this->displayoptions);
+        return (object)[
+            'id' => $mod->id,
+            'module' => $mod->modname,
+            'extraclasses' => $mod->extraclasses,
+            'cmformat' => $item->export_for_template($output),
+        ];
+    }
+}
+
diff --git a/course/classes/output/section_format/cmlist.php b/course/classes/output/section_format/cmlist.php
new file mode 100644
index 00000000000..97e47a01be1
--- /dev/null
+++ b/course/classes/output/section_format/cmlist.php
@@ -0,0 +1,132 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default activity list from a section.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use renderable;
+use templatable;
+use moodle_url;
+use stdClass;
+
+/**
+ * Base class to render a section activity list.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cmlist implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_format the course section class */
+    protected $section;
+
+    /** @var array optional display options */
+    protected $displayoptions;
+
+    /** @var string the item output class name */
+    protected $itemclass;
+
+    /** @var optional move here output class */
+    protected $movehereclass;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     * @param array $displayoptions optional extra display options
+     */
+    public function __construct(course_format $format, section_info $section, array $displayoptions = []) {
+        $this->format = $format;
+        $this->section = $section;
+        $this->displayoptions = $displayoptions;
+
+        // Get the necessary classes.
+        $this->itemclass = $format->get_output_classname('section_format\cmitem');
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+        global $USER;
+
+        $format = $this->format;
+        $section = $this->section;
+        $course = $format->get_course();
+        $modinfo = $format->get_modinfo();
+        $user = $USER;
+
+        $data = new stdClass();
+        $data->cms = [];
+
+        // By default, non-ajax controls are disabled but in some places like the frontpage
+        // it is necessary to display them. This is a temporal solution while JS is still
+        // optional for course editing.
+        $showmovehere = ismoving($course->id);
+
+        if ($showmovehere) {
+            $data->hascms = true;
+            $data->showmovehere = true;
+            $data->strmovefull = strip_tags(get_string("movefull", "", "'$user->activitycopyname'"));
+            $data->movetosectionurl = new moodle_url('/course/mod.php', ['movetosection' => $section->id, 'sesskey' => sesskey()]);
+            $data->movingstr = strip_tags(get_string('activityclipboard', '', $user->activitycopyname));
+            $data->cancelcopyurl = new moodle_url('/course/mod.php', ['cancelcopy' => 'true', 'sesskey' => sesskey()]);
+        }
+
+        if (empty($modinfo->sections[$section->section])) {
+            return $data;
+        }
+
+        foreach ($modinfo->sections[$section->section] as $modnumber) {
+            $mod = $modinfo->cms[$modnumber];
+            // If the old non-ajax move is necessary, we do not print the selected cm.
+            if ($showmovehere && $USER->activitycopy == $mod->id) {
+                continue;
+            }
+            if ($mod->is_visible_on_course_page()) {
+                $item = new $this->itemclass($format, $section, $mod, $this->displayoptions);
+                $data->cms[] = (object)[
+                    'cmitem' => $item->export_for_template($output),
+                    'moveurl' => new moodle_url('/course/mod.php', array('moveto' => $modnumber, 'sesskey' => sesskey())),
+                ];
+            }
+        }
+
+        if (!empty($data->cms)) {
+            $data->hascms = true;
+        }
+
+        return $data;
+    }
+}
+
diff --git a/course/classes/output/section_format/cmsummary.php b/course/classes/output/section_format/cmsummary.php
new file mode 100644
index 00000000000..f4207264d78
--- /dev/null
+++ b/course/classes/output/section_format/cmsummary.php
@@ -0,0 +1,128 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default activities summary (used for singlesection format).
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use completion_info;
+use renderable;
+use templatable;
+use stdClass;
+
+/**
+ * Base class to render a course section summary.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class cmsummary implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the course section class */
+    protected $section;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     */
+    public function __construct(course_format $format, section_info $section) {
+        $this->format = $format;
+        $this->section = $section;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        list($mods, $complete, $total) = $this->calculate_section_stats();
+
+        if (empty($mods)) {
+            return new stdClass();
+        }
+
+        $data = (object)[
+            'total' => $total,
+            'complete' => $complete,
+            'mods' => array_values($mods),
+        ];
+
+        $data->modprogress = get_string('progresstotal', 'completion', $data);
+
+        return $data;
+    }
+
+    /**
+     * Calculate the activities count of the current section.
+     *
+     * @return array with [[count by activity type], completed activities, total of activitites]
+     */
+    private function calculate_section_stats(): array {
+        $format = $this->format;
+        $course = $format->get_course();
+        $section = $this->section;
+        $modinfo = $format->get_modinfo();
+        $completioninfo = new completion_info($course);
+
+        $mods = [];
+        $total = 0;
+        $complete = 0;
+
+        $cmids = $modinfo->sections[$section->section] ?? [];
+
+        $cancomplete = isloggedin() && !isguestuser();
+        foreach ($cmids as $cmid) {
+            $thismod = $modinfo->cms[$cmid];
+
+            if ($thismod->uservisible) {
+                if (isset($mods[$thismod->modname])) {
+                    $mods[$thismod->modname]['name'] = $thismod->modplural;
+                    $mods[$thismod->modname]['count']++;
+                } else {
+                    $mods[$thismod->modname]['name'] = $thismod->modfullname;
+                    $mods[$thismod->modname]['count'] = 1;
+                }
+                if ($cancomplete && $completioninfo->is_enabled($thismod) != COMPLETION_TRACKING_NONE) {
+                    $total++;
+                    $completiondata = $completioninfo->get_data($thismod, true);
+                    if ($completiondata->completionstate == COMPLETION_COMPLETE ||
+                            $completiondata->completionstate == COMPLETION_COMPLETE_PASS) {
+                        $complete++;
+                    }
+                }
+            }
+        }
+
+        return [$mods, $complete, $total];
+    }
+}
diff --git a/course/classes/output/section_format/controlmenu.php b/course/classes/output/section_format/controlmenu.php
new file mode 100644
index 00000000000..4c1d97bbc08
--- /dev/null
+++ b/course/classes/output/section_format/controlmenu.php
@@ -0,0 +1,232 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section controls output class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use renderable;
+use templatable;
+use context_course;
+use moodle_url;
+use pix_icon;
+use action_menu_link_secondary;
+use action_menu;
+use stdClass;
+
+/**
+ * Base class to render section controls.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class controlmenu implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the course section class */
+    protected $section;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     */
+    public function __construct(course_format $format, section_info $section) {
+        $this->format = $format;
+        $this->section = $section;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        $section = $this->section;
+
+        $controls = $this->section_control_items();
+
+        if (empty($controls)) {
+            return new stdClass();
+        }
+
+        // Convert control array into an action_menu.
+        $menu = new action_menu();
+        $menu->set_menu_trigger(get_string('edit'));
+        $menu->attributes['class'] .= ' section-actions';
+        foreach ($controls as $value) {
+            $url = empty($value['url']) ? '' : $value['url'];
+            $icon = empty($value['icon']) ? '' : $value['icon'];
+            $name = empty($value['name']) ? '' : $value['name'];
+            $attr = empty($value['attr']) ? array() : $value['attr'];
+            $class = empty($value['pixattr']['class']) ? '' : $value['pixattr']['class'];
+            $al = new action_menu_link_secondary(
+                new moodle_url($url),
+                new pix_icon($icon, '', null, array('class' => "smallicon " . $class)),
+                $name,
+                $attr
+            );
+            $menu->add($al);
+        }
+
+        $data = (object)[
+            'menu' => $output->render($menu),
+            'hasmenu' => true,
+            'id' => $section->id,
+        ];
+
+        return $data;
+    }
+
+    /**
+     * Generate the edit control items of a section.
+     *
+     * It is not clear this kind of controls are still available in 4.0 so, for now, this
+     * method is almost a clone of the previous section_control_items from the course/renderer.php.
+     *
+     * This method must remain public until the final deprecation of section_edit_control_items.
+     *
+     * @return array of edit control items
+     */
+    public function section_control_items() {
+        global $USER;
+
+        $format = $this->format;
+        $section = $this->section;
+        $course = $format->get_course();
+        $sectionreturn = $format->get_section_number();
+        $user = $USER;
+
+        $coursecontext = context_course::instance($course->id);
+        $numsections = $format->get_last_section_number();
+        $isstealth = $section->section > $numsections;
+
+        $baseurl = course_get_url($course, $sectionreturn);
+        $baseurl->param('sesskey', sesskey());
+
+        $controls = [];
+
+        if (!$isstealth && has_capability('moodle/course:update', $coursecontext, $user)) {
+            if ($section->section > 0
+                && get_string_manager()->string_exists('editsection', 'format_'.$format->get_format())) {
+                $streditsection = get_string('editsection', 'format_'.$format->get_format());
+            } else {
+                $streditsection = get_string('editsection');
+            }
+
+            $controls['edit'] = array(
+                'url'   => new moodle_url('/course/editsection.php', array('id' => $section->id, 'sr' => $sectionreturn)),
+                'icon' => 'i/settings',
+                'name' => $streditsection,
+                'pixattr' => array('class' => ''),
+                'attr' => array('class' => 'icon edit'));
+        }
+
+        if ($section->section) {
+            $url = clone($baseurl);
+            if (!$isstealth) {
+                if (has_capability('moodle/course:sectionvisibility', $coursecontext, $user)) {
+                    if ($section->visible) { // Show the hide/show eye.
+                        $strhidefromothers = get_string('hidefromothers', 'format_'.$course->format);
+                        $url->param('hide', $section->section);
+                        $controls['visiblity'] = array(
+                            'url' => $url,
+                            'icon' => 'i/hide',
+                            'name' => $strhidefromothers,
+                            'pixattr' => array('class' => ''),
+                            'attr' => array('class' => 'icon editing_showhide',
+                                'data-sectionreturn' => $sectionreturn, 'data-action' => 'hide'));
+                    } else {
+                        $strshowfromothers = get_string('showfromothers', 'format_'.$course->format);
+                        $url->param('show',  $section->section);
+                        $controls['visiblity'] = array(
+                            'url' => $url,
+                            'icon' => 'i/show',
+                            'name' => $strshowfromothers,
+                            'pixattr' => array('class' => ''),
+                            'attr' => array('class' => 'icon editing_showhide',
+                                'data-sectionreturn' => $sectionreturn, 'data-action' => 'show'));
+                    }
+                }
+
+                if (!$sectionreturn) {
+                    if (has_capability('moodle/course:movesections', $coursecontext, $user)) {
+                        $url = clone($baseurl);
+                        if ($section->section > 1) { // Add a arrow to move section up.
+                            $url->param('section', $section->section);
+                            $url->param('move', -1);
+                            $strmoveup = get_string('moveup');
+                            $controls['moveup'] = array(
+                                'url' => $url,
+                                'icon' => 'i/up',
+                                'name' => $strmoveup,
+                                'pixattr' => array('class' => ''),
+                                'attr' => array('class' => 'icon moveup'));
+                        }
+
+                        $url = clone($baseurl);
+                        if ($section->section < $numsections) { // Add a arrow to move section down.
+                            $url->param('section', $section->section);
+                            $url->param('move', 1);
+                            $strmovedown = get_string('movedown');
+                            $controls['movedown'] = array(
+                                'url' => $url,
+                                'icon' => 'i/down',
+                                'name' => $strmovedown,
+                                'pixattr' => array('class' => ''),
+                                'attr' => array('class' => 'icon movedown'));
+                        }
+                    }
+                }
+            }
+
+            if (course_can_delete_section($course, $section)) {
+                if (get_string_manager()->string_exists('deletesection', 'format_'.$course->format)) {
+                    $strdelete = get_string('deletesection', 'format_'.$course->format);
+                } else {
+                    $strdelete = get_string('deletesection');
+                }
+                $url = new moodle_url('/course/editsection.php', array(
+                    'id' => $section->id,
+                    'sr' => $sectionreturn,
+                    'delete' => 1,
+                    'sesskey' => sesskey()));
+                $controls['delete'] = array(
+                    'url' => $url,
+                    'icon' => 'i/delete',
+                    'name' => $strdelete,
+                    'pixattr' => array('class' => ''),
+                    'attr' => array('class' => 'icon editing_delete'));
+            }
+        }
+
+        return $controls;
+    }
+}
diff --git a/course/classes/output/section_format/header.php b/course/classes/output/section_format/header.php
new file mode 100644
index 00000000000..c49a4d563d0
--- /dev/null
+++ b/course/classes/output/section_format/header.php
@@ -0,0 +1,99 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section header format output class.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use renderable;
+use templatable;
+use stdClass;
+
+/**
+ * Base class to render a section header.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class header implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the course section class */
+    protected $section;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     */
+    public function __construct(course_format $format, section_info $section) {
+        $this->format = $format;
+        $this->section = $section;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        $format = $this->format;
+        $section = $this->section;
+        $course = $format->get_course();
+
+        $data = (object)[
+            'num' => $section->section,
+            'id' => $section->id,
+        ];
+
+        if ($section->section > $format->get_last_section_number()) {
+            // Stealth sections (orphaned) has special title.
+            $data->title = get_string('orphanedactivitiesinsectionno', '', $section->section);
+        } else if ($section->section == $format->get_section_number()) {
+            // Regular section title.
+            $data->title = $output->section_title_without_link($section, $course);
+            $data->issinglesection = true;
+        } else {
+            // Regular section title.
+            $data->title = $output->section_title($section, $course);
+        }
+
+        if (!$section->visible) {
+            $data->ishidden = true;
+        }
+
+        if (!$format->show_editor() && $course->coursedisplay == COURSE_DISPLAY_MULTIPAGE && empty($data->issinglesection)) {
+            $data->url = course_get_url($course, $section->section);
+            $data->name = get_section_name($course, $section);
+        }
+
+        return $data;
+    }
+}
diff --git a/course/classes/output/section_format/summary.php b/course/classes/output/section_format/summary.php
new file mode 100644
index 00000000000..60bf6d3c73d
--- /dev/null
+++ b/course/classes/output/section_format/summary.php
@@ -0,0 +1,94 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section summary (used for multipage format).
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace core_course\output\section_format;
+
+use core_course\course_format;
+use section_info;
+use renderable;
+use templatable;
+use context_course;
+use stdClass;
+
+/**
+ * Base class to render a course section summary.
+ *
+ * @package   core_course
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class summary implements renderable, templatable {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the course section class */
+    private $section;
+
+    /**
+     * Constructor.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     */
+    public function __construct(course_format $format, section_info $section) {
+        $this->format = $format;
+        $this->section = $section;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output typically, the renderer that's calling this function
+     * @return array data context for a mustache template
+     */
+    public function export_for_template(\renderer_base $output): stdClass {
+
+        $section = $this->section;
+
+        $data = new stdClass();
+
+        if ($section->uservisible || $section->visible) {
+            $data->summarytext = $this->format_summary_text();
+        }
+        return $data;
+    }
+
+    /**
+     * Generate html for a section summary text
+     *
+     * @return string HTML to output.
+     */
+    public function format_summary_text(): string {
+        $section = $this->section;
+        $context = context_course::instance($section->course);
+        $summarytext = file_rewrite_pluginfile_urls($section->summary, 'pluginfile.php',
+            $context->id, 'course', 'section', $section->id);
+
+        $options = new stdClass();
+        $options->noclean = true;
+        $options->overflowdiv = true;
+        return format_text($summarytext, $section->summaryformat, $options);
+    }
+}
diff --git a/course/dnduploadlib.php b/course/dnduploadlib.php
index 11289b1b3f5..3feb01ff262 100644
--- a/course/dnduploadlib.php
+++ b/course/dnduploadlib.php
@@ -652,13 +652,13 @@ class dndupload_ajax_processor {
         $resp->error = self::ERROR_OK;
         $resp->elementid = 'module-' . $mod->id;
 
-        $courserenderer = $PAGE->get_renderer('core', 'course');
-        $completioninfo = new completion_info($this->course);
-        $info = get_fast_modinfo($this->course);
-        $sr = null;
-        $modulehtml = $courserenderer->course_section_cm($this->course, $completioninfo,
-                $mod, null, array());
-        $resp->fullcontent = $courserenderer->course_section_cm_list_item($this->course, $completioninfo, $mod, $sr);
+        $format = course_get_format($this->course);
+        $renderer = $format->get_renderer($PAGE);
+        $modinfo = $format->get_modinfo();
+        $section = $modinfo->get_section_info($mod->sectionnum);
+
+        // Get the new element html content.
+        $resp->fullcontent = $renderer->course_section_updated_cm_item($format, $section, $mod);
 
         echo $OUTPUT->header();
         echo json_encode($resp);
diff --git a/course/externallib.php b/course/externallib.php
index 0e61c579ebb..a93d7734cfa 100644
--- a/course/externallib.php
+++ b/course/externallib.php
@@ -3521,8 +3521,11 @@ class core_course_external extends external_api {
         $modcontext = context_module::instance($cm->id);
         $coursecontext = context_course::instance($course->id);
         self::validate_context($modcontext);
-        $courserenderer = $PAGE->get_renderer('core', 'course');
-        $completioninfo = new completion_info($course);
+        $format = course_get_format($course);
+        if ($sectionreturn) {
+            $format->set_section_number($sectionreturn);
+        }
+        $renderer = $format->get_renderer($PAGE);
 
         switch($action) {
             case 'hide':
@@ -3542,10 +3545,15 @@ class core_course_external extends external_api {
                     throw new moodle_exception('No permission to create that activity');
                 }
                 if ($newcm = duplicate_module($course, $cm)) {
-                    $cm = get_fast_modinfo($course)->get_cm($id);
-                    $newcm = get_fast_modinfo($course)->get_cm($newcm->id);
-                    return $courserenderer->course_section_cm_list_item($course, $completioninfo, $cm, $sectionreturn) .
-                        $courserenderer->course_section_cm_list_item($course, $completioninfo, $newcm, $sectionreturn);
+
+                    $modinfo = $format->get_modinfo();
+                    $section = $modinfo->get_section_info($newcm->sectionnum);
+                    $cm = $modinfo->get_cm($id);
+
+                    // Get both original and new element html.
+                    $result = $renderer->course_section_updated_cm_item($format, $section, $cm);
+                    $result .= $renderer->course_section_updated_cm_item($format, $section, $newcm);
+                    return $result;
                 }
                 break;
             case 'groupsseparate':
@@ -3580,8 +3588,10 @@ class core_course_external extends external_api {
                 throw new coding_exception('Unrecognised action');
         }
 
-        $cm = get_fast_modinfo($course)->get_cm($id);
-        return $courserenderer->course_section_cm_list_item($course, $completioninfo, $cm, $sectionreturn);
+        $modinfo = $format->get_modinfo();
+        $section = $modinfo->get_section_info($cm->sectionnum);
+        $cm = $modinfo->get_cm($id);
+        return $renderer->course_section_updated_cm_item($format, $section, $cm);
     }
 
     /**
@@ -3639,9 +3649,15 @@ class core_course_external extends external_api {
         list($course, $cm) = get_course_and_cm_from_cmid($id);
         self::validate_context(context_course::instance($course->id));
 
-        $courserenderer = $PAGE->get_renderer('core', 'course');
-        $completioninfo = new completion_info($course);
-        return $courserenderer->course_section_cm_list_item($course, $completioninfo, $cm, $sectionreturn);
+        $format = course_get_format($course);
+        if ($sectionreturn) {
+            $format->set_section_number($sectionreturn);
+        }
+        $renderer = $format->get_renderer($PAGE);
+
+        $modinfo = $format->get_modinfo();
+        $section = $modinfo->get_section_info($cm->sectionnum);
+        return $renderer->course_section_updated_cm_item($format, $section, $cm);
     }
 
     /**
diff --git a/course/format/README.txt b/course/format/README.txt
index 6705b5b6ca8..4e319331c67 100644
--- a/course/format/README.txt
+++ b/course/format/README.txt
@@ -9,6 +9,10 @@ below.
 If you want to store information in the database for your format, or control
 access to features of your format, you need some of the optional files too.
 
+If you want to override some standard course output component (located in
+coure/classes/output/{course|section|cm}_format/*) you need to create an
+extend class inside your course/format/yourformat/classes/output.
+
 All names below assume that your format is called 'yourformat'.
 
 
@@ -139,3 +143,31 @@ Optional file (styles)
 
   If this file exists it will be included in the CSS Moodle generates.
 
+
+Optional files (outputs)
+----------------------
+
+By default, the format renderer will use those output classes:
+
+* core_course\output\course_format: for the general course structure
+* core_course\output\course_format\*: to render specific course structure parts
+
+* core_course\output\section_format: for the complete section output
+* core_course\output\section_format\*: to render specific section parts
+
+* core_course\output\cm_format: for output an activity inside a section
+* core_course\output\cm_format\*: for speficis parts of the cm output
+
+  Your format can override any of this output classes just by creating class
+  inside your format_yourformat\output\ classes. We recommend to extend the
+  original class to ensure all element will work as expected.
+
+  For example: if you want to change the section header, you should create
+  format_yourformat\output\section_format\header, which will extend the original
+  core_course\output\section_format\header class.
+
+  By default, only two format renderer methods are needed to render a course:
+  - render_course_format to render a full course
+  - course_section_updated_cm_item used by the course editor to refresh a specific cm item
+
+  Formats can override those two methods to use different templates to render a course.
diff --git a/course/format/lib.php b/course/format/lib.php
index 40c880d5eb1..72bd6fb5015 100644
--- a/course/format/lib.php
+++ b/course/format/lib.php
@@ -24,1308 +24,17 @@
 
 defined('MOODLE_INTERNAL') || die;
 
+use core_course\course_format;
+
 /**
- * Returns an instance of format class (extending format_base) for given course
+ * Returns an instance of format class (extending course_format) for given course
  *
  * @param int|stdClass $courseorid either course id or
  *     an object that has the property 'format' and may contain property 'id'
- * @return format_base
+ * @return course_format
  */
 function course_get_format($courseorid) {
-    return format_base::instance($courseorid);
-}
-
-/**
- * Base class for course formats
- *
- * Each course format must declare class
- * class format_FORMATNAME extends format_base {}
- * in file lib.php
- *
- * For each course just one instance of this class is created and it will always be returned by
- * course_get_format($courseorid). Format may store it's specific course-dependent options in
- * variables of this class.
- *
- * In rare cases instance of child class may be created just for format without course id
- * i.e. to check if format supports AJAX.
- *
- * Also course formats may extend class section_info and overwrite
- * format_base::build_section_cache() to return more information about sections.
- *
- * If you are upgrading from Moodle 2.3 start with copying the class format_legacy and renaming
- * it to format_FORMATNAME, then move the code from your callback functions into
- * appropriate functions of the class.
- *
- * @package    core_course
- * @copyright  2012 Marina Glancy
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-abstract class format_base {
-    /** @var int Id of the course in this instance (maybe 0) */
-    protected $courseid;
-    /** @var string format used for this course. Please note that it can be different from
-     * course.format field if course referes to non-existing of disabled format */
-    protected $format;
-    /** @var stdClass data for course object, please use {@link format_base::get_course()} */
-    protected $course = false;
-    /** @var array caches format options, please use {@link format_base::get_format_options()} */
-    protected $formatoptions = array();
-    /** @var array cached instances */
-    private static $instances = array();
-    /** @var array plugin name => class name. */
-    private static $classesforformat = array('site' => 'site');
-
-    /**
-     * Creates a new instance of class
-     *
-     * Please use {@link course_get_format($courseorid)} to get an instance of the format class
-     *
-     * @param string $format
-     * @param int $courseid
-     * @return format_base
-     */
-    protected function __construct($format, $courseid) {
-        $this->format = $format;
-        $this->courseid = $courseid;
-    }
-
-    /**
-     * Validates that course format exists and enabled and returns either itself or default format
-     *
-     * @param string $format
-     * @return string
-     */
-    protected static final function get_format_or_default($format) {
-        global $CFG;
-        require_once($CFG->dirroot . '/course/lib.php');
-
-        if (array_key_exists($format, self::$classesforformat)) {
-            return self::$classesforformat[$format];
-        }
-
-        $plugins = get_sorted_course_formats();
-        foreach ($plugins as $plugin) {
-            self::$classesforformat[$plugin] = $plugin;
-        }
-
-        if (array_key_exists($format, self::$classesforformat)) {
-            return self::$classesforformat[$format];
-        }
-
-        if (PHPUNIT_TEST && class_exists('format_' . $format)) {
-            // Allow unittests to use non-existing course formats.
-            return $format;
-        }
-
-        // Else return default format
-        $defaultformat = get_config('moodlecourse', 'format');
-        if (!in_array($defaultformat, $plugins)) {
-            // when default format is not set correctly, use the first available format
-            $defaultformat = reset($plugins);
-        }
-        debugging('Format plugin format_'.$format.' is not found. Using default format_'.$defaultformat, DEBUG_DEVELOPER);
-
-        self::$classesforformat[$format] = $defaultformat;
-        return $defaultformat;
-    }
-
-    /**
-     * Get class name for the format
-     *
-     * If course format xxx does not declare class format_xxx, format_legacy will be returned.
-     * This function also includes lib.php file from corresponding format plugin
-     *
-     * @param string $format
-     * @return string
-     */
-    protected static final function get_class_name($format) {
-        global $CFG;
-        static $classnames = array('site' => 'format_site');
-        if (!isset($classnames[$format])) {
-            $plugins = core_component::get_plugin_list('format');
-            $usedformat = self::get_format_or_default($format);
-            if (isset($plugins[$usedformat]) && file_exists($plugins[$usedformat].'/lib.php')) {
-                require_once($plugins[$usedformat].'/lib.php');
-            }
-            $classnames[$format] = 'format_'. $usedformat;
-            if (!class_exists($classnames[$format])) {
-                require_once($CFG->dirroot.'/course/format/formatlegacy.php');
-                $classnames[$format] = 'format_legacy';
-            }
-        }
-        return $classnames[$format];
-    }
-
-    /**
-     * Returns an instance of the class
-     *
-     * @todo MDL-35727 use MUC for caching of instances, limit the number of cached instances
-     *
-     * @param int|stdClass $courseorid either course id or
-     *     an object that has the property 'format' and may contain property 'id'
-     * @return format_base
-     */
-    public static final function instance($courseorid) {
-        global $DB;
-        if (!is_object($courseorid)) {
-            $courseid = (int)$courseorid;
-            if ($courseid && isset(self::$instances[$courseid]) && count(self::$instances[$courseid]) == 1) {
-                $formats = array_keys(self::$instances[$courseid]);
-                $format = reset($formats);
-            } else {
-                $format = $DB->get_field('course', 'format', array('id' => $courseid), MUST_EXIST);
-            }
-        } else {
-            $format = $courseorid->format;
-            if (isset($courseorid->id)) {
-                $courseid = clean_param($courseorid->id, PARAM_INT);
-            } else {
-                $courseid = 0;
-            }
-        }
-        // validate that format exists and enabled, use default otherwise
-        $format = self::get_format_or_default($format);
-        if (!isset(self::$instances[$courseid][$format])) {
-            $classname = self::get_class_name($format);
-            self::$instances[$courseid][$format] = new $classname($format, $courseid);
-        }
-        return self::$instances[$courseid][$format];
-    }
-
-    /**
-     * Resets cache for the course (or all caches)
-     * To be called from {@link rebuild_course_cache()}
-     *
-     * @param int $courseid
-     */
-    public static final function reset_course_cache($courseid = 0) {
-        if ($courseid) {
-            if (isset(self::$instances[$courseid])) {
-                foreach (self::$instances[$courseid] as $format => $object) {
-                    // in case somebody keeps the reference to course format object
-                    self::$instances[$courseid][$format]->course = false;
-                    self::$instances[$courseid][$format]->formatoptions = array();
-                }
-                unset(self::$instances[$courseid]);
-            }
-        } else {
-            self::$instances = array();
-        }
-    }
-
-    /**
-     * Returns the format name used by this course
-     *
-     * @return string
-     */
-    public final function get_format() {
-        return $this->format;
-    }
-
-    /**
-     * Returns id of the course (0 if course is not specified)
-     *
-     * @return int
-     */
-    public final function get_courseid() {
-        return $this->courseid;
-    }
-
-    /**
-     * Returns a record from course database table plus additional fields
-     * that course format defines
-     *
-     * @return stdClass
-     */
-    public function get_course() {
-        global $DB;
-        if (!$this->courseid) {
-            return null;
-        }
-        if ($this->course === false) {
-            $this->course = get_course($this->courseid);
-            $options = $this->get_format_options();
-            $dbcoursecolumns = null;
-            foreach ($options as $optionname => $optionvalue) {
-                if (isset($this->course->$optionname)) {
-                    // Course format options must not have the same names as existing columns in db table "course".
-                    if (!isset($dbcoursecolumns)) {
-                        $dbcoursecolumns = $DB->get_columns('course');
-                    }
-                    if (isset($dbcoursecolumns[$optionname])) {
-                        debugging('The option name '.$optionname.' in course format '.$this->format.
-                            ' is invalid because the field with the same name exists in {course} table',
-                            DEBUG_DEVELOPER);
-                        continue;
-                    }
-                }
-                $this->course->$optionname = $optionvalue;
-            }
-        }
-        return $this->course;
-    }
-
-    /**
-     * Method used in the rendered and during backup instead of legacy 'numsections'
-     *
-     * Default renderer will treat sections with sectionnumber greater that the value returned by this
-     * method as "orphaned" and not display them on the course page unless in editing mode.
-     * Backup will store this value as 'numsections'.
-     *
-     * This method ensures that 3rd party course format plugins that still use 'numsections' continue to
-     * work but at the same time we no longer expect formats to have 'numsections' property.
-     *
-     * @return int
-     */
-    public function get_last_section_number() {
-        $course = $this->get_course();
-        if (isset($course->numsections)) {
-            return $course->numsections;
-        }
-        $modinfo = get_fast_modinfo($course);
-        $sections = $modinfo->get_section_info_all();
-        return (int)max(array_keys($sections));
-    }
-
-    /**
-     * Method used to get the maximum number of sections for this course format.
-     * @return int
-     */
-    public function get_max_sections() {
-        $maxsections = get_config('moodlecourse', 'maxsections');
-        if (!isset($maxsections) || !is_numeric($maxsections)) {
-            $maxsections = 52;
-        }
-        return $maxsections;
-    }
-
-    /**
-     * Returns true if the course has a front page.
-     *
-     * This function is called to determine if the course has a view page, whether or not
-     * it contains a listing of activities. It can be useful to set this to false when the course
-     * format has only one activity and ignores the course page. Or if there are multiple
-     * activities but no page to see the centralised information.
-     *
-     * Initially this was created to know if forms should add a button to return to the course page.
-     * So if 'Return to course' does not make sense in your format your should probably return false.
-     *
-     * @return boolean
-     * @since Moodle 2.6
-     */
-    public function has_view_page() {
-        return true;
-    }
-
-    /**
-     * Returns true if this course format uses sections
-     *
-     * This function may be called without specifying the course id
-     * i.e. in {@link course_format_uses_sections()}
-     *
-     * Developers, note that if course format does use sections there should be defined a language
-     * string with the name 'sectionname' defining what the section relates to in the format, i.e.
-     * $string['sectionname'] = 'Topic';
-     * or
-     * $string['sectionname'] = 'Week';
-     *
-     * @return bool
-     */
-    public function uses_sections() {
-        return false;
-    }
-
-    /**
-     * Returns a list of sections used in the course
-     *
-     * This is a shortcut to get_fast_modinfo()->get_section_info_all()
-     * @see get_fast_modinfo()
-     * @see course_modinfo::get_section_info_all()
-     *
-     * @return array of section_info objects
-     */
-    public final function get_sections() {
-        if ($course = $this->get_course()) {
-            $modinfo = get_fast_modinfo($course);
-            return $modinfo->get_section_info_all();
-        }
-        return array();
-    }
-
-    /**
-     * Returns information about section used in course
-     *
-     * @param int|stdClass $section either section number (field course_section.section) or row from course_section table
-     * @param int $strictness
-     * @return section_info
-     */
-    public final function get_section($section, $strictness = IGNORE_MISSING) {
-        if (is_object($section)) {
-            $sectionnum = $section->section;
-        } else {
-            $sectionnum = $section;
-        }
-        $sections = $this->get_sections();
-        if (array_key_exists($sectionnum, $sections)) {
-            return $sections[$sectionnum];
-        }
-        if ($strictness == MUST_EXIST) {
-            throw new moodle_exception('sectionnotexist');
-        }
-        return null;
-    }
-
-    /**
-     * Returns the display name of the given section that the course prefers.
-     *
-     * @param int|stdClass $section Section object from database or just field course_sections.section
-     * @return Display name that the course format prefers, e.g. "Topic 2"
-     */
-    public function get_section_name($section) {
-        if (is_object($section)) {
-            $sectionnum = $section->section;
-        } else {
-            $sectionnum = $section;
-        }
-
-        if (get_string_manager()->string_exists('sectionname', 'format_' . $this->format)) {
-            return get_string('sectionname', 'format_' . $this->format) . ' ' . $sectionnum;
-        }
-
-        // Return an empty string if there's no available section name string for the given format.
-        return '';
-    }
-
-    /**
-     * Returns the default section using format_base's implementation of get_section_name.
-     *
-     * @param int|stdClass $section Section object from database or just field course_sections section
-     * @return string The default value for the section name based on the given course format.
-     */
-    public function get_default_section_name($section) {
-        return self::get_section_name($section);
-    }
-
-    /**
-     * Returns the information about the ajax support in the given source format
-     *
-     * The returned object's property (boolean)capable indicates that
-     * the course format supports Moodle course ajax features.
-     *
-     * @return stdClass
-     */
-    public function supports_ajax() {
-        // no support by default
-        $ajaxsupport = new stdClass();
-        $ajaxsupport->capable = false;
-        return $ajaxsupport;
-    }
-
-    /**
-     * Custom action after section has been moved in AJAX mode
-     *
-     * Used in course/rest.php
-     *
-     * @return array This will be passed in ajax respose
-     */
-    public function ajax_section_move() {
-        return null;
-    }
-
-    /**
-     * The URL to use for the specified course (with section)
-     *
-     * Please note that course view page /course/view.php?id=COURSEID is hardcoded in many
-     * places in core and contributed modules. If course format wants to change the location
-     * of the view script, it is not enough to change just this function. Do not forget
-     * to add proper redirection.
-     *
-     * @param int|stdClass $section Section object from database or just field course_sections.section
-     *     if null the course view page is returned
-     * @param array $options options for view URL. At the moment core uses:
-     *     'navigation' (bool) if true and section has no separate page, the function returns null
-     *     'sr' (int) used by multipage formats to specify to which section to return
-     * @return null|moodle_url
-     */
-    public function get_view_url($section, $options = array()) {
-        global $CFG;
-        $course = $this->get_course();
-        $url = new moodle_url('/course/view.php', array('id' => $course->id));
-
-        if (array_key_exists('sr', $options)) {
-            $sectionno = $options['sr'];
-        } else if (is_object($section)) {
-            $sectionno = $section->section;
-        } else {
-            $sectionno = $section;
-        }
-        if (empty($CFG->linkcoursesections) && !empty($options['navigation']) && $sectionno !== null) {
-            // by default assume that sections are never displayed on separate pages
-            return null;
-        }
-        if ($this->uses_sections() && $sectionno !== null) {
-            $url->set_anchor('section-'.$sectionno);
-        }
-        return $url;
-    }
-
-    /**
-     * Loads all of the course sections into the navigation
-     *
-     * This method is called from {@link global_navigation::load_course_sections()}
-     *
-     * By default the method {@link global_navigation::load_generic_course_sections()} is called
-     *
-     * When overwriting please note that navigationlib relies on using the correct values for
-     * arguments $type and $key in {@link navigation_node::add()}
-     *
-     * Example of code creating a section node:
-     * $sectionnode = $node->add($sectionname, $url, navigation_node::TYPE_SECTION, null, $section->id);
-     * $sectionnode->nodetype = navigation_node::NODETYPE_BRANCH;
-     *
-     * Example of code creating an activity node:
-     * $activitynode = $sectionnode->add($activityname, $action, navigation_node::TYPE_ACTIVITY, null, $activity->id, $icon);
-     * if (global_navigation::module_extends_navigation($activity->modname)) {
-     *     $activitynode->nodetype = navigation_node::NODETYPE_BRANCH;
-     * } else {
-     *     $activitynode->nodetype = navigation_node::NODETYPE_LEAF;
-     * }
-     *
-     * Also note that if $navigation->includesectionnum is not null, the section with this relative
-     * number needs is expected to be loaded
-     *
-     * @param global_navigation $navigation
-     * @param navigation_node $node The course node within the navigation
-     */
-    public function extend_course_navigation($navigation, navigation_node $node) {
-        if ($course = $this->get_course()) {
-            $navigation->load_generic_course_sections($course, $node);
-        }
-        return array();
-    }
-
-    /**
-     * Returns the list of blocks to be automatically added for the newly created course
-     *
-     * @see blocks_add_default_course_blocks()
-     *
-     * @return array of default blocks, must contain two keys BLOCK_POS_LEFT and BLOCK_POS_RIGHT
-     *     each of values is an array of block names (for left and right side columns)
-     */
-    public function get_default_blocks() {
-        global $CFG;
-        if (isset($CFG->defaultblocks)) {
-            return blocks_parse_default_blocks_list($CFG->defaultblocks);
-        }
-        $blocknames = array(
-            BLOCK_POS_LEFT => array(),
-            BLOCK_POS_RIGHT => array()
-        );
-        return $blocknames;
-    }
-
-    /**
-     * Returns the localised name of this course format plugin
-     *
-     * @return lang_string
-     */
-    public final function get_format_name() {
-        return new lang_string('pluginname', 'format_'.$this->get_format());
-    }
-
-    /**
-     * Definitions of the additional options that this course format uses for course
-     *
-     * This function may be called often, it should be as fast as possible.
-     * Avoid using get_string() method, use "new lang_string()" instead
-     * It is not recommended to use dynamic or course-dependant expressions here
-     * This function may be also called when course does not exist yet.
-     *
-     * Option names must be different from fields in the {course} talbe or any form elements on
-     * course edit form, it may even make sence to use special prefix for them.
-     *
-     * Each option must have the option name as a key and the array of properties as a value:
-     * 'default' - default value for this option (assumed null if not specified)
-     * 'type' - type of the option value (PARAM_INT, PARAM_RAW, etc.)
-     *
-     * Additional properties used by default implementation of
-     * {@link format_base::create_edit_form_elements()} (calls this method with $foreditform = true)
-     * 'label' - localised human-readable label for the edit form
-     * 'element_type' - type of the form element, default 'text'
-     * 'element_attributes' - additional attributes for the form element, these are 4th and further
-     *    arguments in the moodleform::addElement() method
-     * 'help' - string for help button. Note that if 'help' value is 'myoption' then the string with
-     *    the name 'myoption_help' must exist in the language file
-     * 'help_component' - language component to look for help string, by default this the component
-     *    for this course format
-     *
-     * This is an interface for creating simple form elements. If format plugin wants to use other
-     * methods such as disableIf, it can be done by overriding create_edit_form_elements().
-     *
-     * Course format options can be accessed as:
-     * $this->get_course()->OPTIONNAME (inside the format class)
-     * course_get_format($course)->get_course()->OPTIONNAME (outside of format class)
-     *
-     * All course options are returned by calling:
-     * $this->get_format_options();
-     *
-     * @param bool $foreditform
-     * @return array of options
-     */
-    public function course_format_options($foreditform = false) {
-        return array();
-    }
-
-    /**
-     * Definitions of the additional options that this course format uses for section
-     *
-     * See {@link format_base::course_format_options()} for return array definition.
-     *
-     * Additionally section format options may have property 'cache' set to true
-     * if this option needs to be cached in {@link get_fast_modinfo()}. The 'cache' property
-     * is recommended to be set only for fields used in {@link format_base::get_section_name()},
-     * {@link format_base::extend_course_navigation()} and {@link format_base::get_view_url()}
-     *
-     * For better performance cached options are recommended to have 'cachedefault' property
-     * Unlike 'default', 'cachedefault' should be static and not access get_config().
-     *
-     * Regardless of value of 'cache' all options are accessed in the code as
-     * $sectioninfo->OPTIONNAME
-     * where $sectioninfo is instance of section_info, returned by
-     * get_fast_modinfo($course)->get_section_info($sectionnum)
-     * or get_fast_modinfo($course)->get_section_info_all()
-     *
-     * All format options for particular section are returned by calling:
-     * $this->get_format_options($section);
-     *
-     * @param bool $foreditform
-     * @return array
-     */
-    public function section_format_options($foreditform = false) {
-        return array();
-    }
-
-    /**
-     * Returns the format options stored for this course or course section
-     *
-     * When overriding please note that this function is called from rebuild_course_cache()
-     * and section_info object, therefore using of get_fast_modinfo() and/or any function that
-     * accesses it may lead to recursion.
-     *
-     * @param null|int|stdClass|section_info $section if null the course format options will be returned
-     *     otherwise options for specified section will be returned. This can be either
-     *     section object or relative section number (field course_sections.section)
-     * @return array
-     */
-    public function get_format_options($section = null) {
-        global $DB;
-        if ($section === null) {
-            $options = $this->course_format_options();
-        } else {
-            $options = $this->section_format_options();
-        }
-        if (empty($options)) {
-            // there are no option for course/sections anyway, no need to go further
-            return array();
-        }
-        if ($section === null) {
-            // course format options will be returned
-            $sectionid = 0;
-        } else if ($this->courseid && isset($section->id)) {
-            // course section format options will be returned
-            $sectionid = $section->id;
-        } else if ($this->courseid && is_int($section) &&
-                ($sectionobj = $DB->get_record('course_sections',
-                        array('section' => $section, 'course' => $this->courseid), 'id'))) {
-            // course section format options will be returned
-            $sectionid = $sectionobj->id;
-        } else {
-            // non-existing (yet) section was passed as an argument
-            // default format options for course section will be returned
-            $sectionid = -1;
-        }
-        if (!array_key_exists($sectionid, $this->formatoptions)) {
-            $this->formatoptions[$sectionid] = array();
-            // first fill with default values
-            foreach ($options as $optionname => $optionparams) {
-                $this->formatoptions[$sectionid][$optionname] = null;
-                if (array_key_exists('default', $optionparams)) {
-                    $this->formatoptions[$sectionid][$optionname] = $optionparams['default'];
-                }
-            }
-            if ($this->courseid && $sectionid !== -1) {
-                // overwrite the default options values with those stored in course_format_options table
-                // nothing can be stored if we are interested in generic course ($this->courseid == 0)
-                // or generic section ($sectionid === 0)
-                $records = $DB->get_records('course_format_options',
-                        array('courseid' => $this->courseid,
-                              'format' => $this->format,
-                              'sectionid' => $sectionid
-                            ), '', 'id,name,value');
-                foreach ($records as $record) {
-                    if (array_key_exists($record->name, $this->formatoptions[$sectionid])) {
-                        $value = $record->value;
-                        if ($value !== null && isset($options[$record->name]['type'])) {
-                            // this will convert string value to number if needed
-                            $value = clean_param($value, $options[$record->name]['type']);
-                        }
-                        $this->formatoptions[$sectionid][$record->name] = $value;
-                    }
-                }
-            }
-        }
-        return $this->formatoptions[$sectionid];
-    }
-
-    /**
-     * Adds format options elements to the course/section edit form
-     *
-     * This function is called from {@link course_edit_form::definition_after_data()}
-     *
-     * @param MoodleQuickForm $mform form the elements are added to
-     * @param bool $forsection 'true' if this is a section edit form, 'false' if this is course edit form
-     * @return array array of references to the added form elements
-     */
-    public function create_edit_form_elements(&$mform, $forsection = false) {
-        $elements = array();
-        if ($forsection) {
-            $options = $this->section_format_options(true);
-        } else {
-            $options = $this->course_format_options(true);
-        }
-        foreach ($options as $optionname => $option) {
-            if (!isset($option['element_type'])) {
-                $option['element_type'] = 'text';
-            }
-            $args = array($option['element_type'], $optionname, $option['label']);
-            if (!empty($option['element_attributes'])) {
-                $args = array_merge($args, $option['element_attributes']);
-            }
-            $elements[] = call_user_func_array(array($mform, 'addElement'), $args);
-            if (isset($option['help'])) {
-                $helpcomponent = 'format_'. $this->get_format();
-                if (isset($option['help_component'])) {
-                    $helpcomponent = $option['help_component'];
-                }
-                $mform->addHelpButton($optionname, $option['help'], $helpcomponent);
-            }
-            if (isset($option['type'])) {
-                $mform->setType($optionname, $option['type']);
-            }
-            if (isset($option['default']) && !array_key_exists($optionname, $mform->_defaultValues)) {
-                // Set defaults for the elements in the form.
-                // Since we call this method after set_data() make sure that we don't override what was already set.
-                $mform->setDefault($optionname, $option['default']);
-            }
-        }
-
-        if (!$forsection && empty($this->courseid)) {
-            // Check if course end date form field should be enabled by default.
-            // If a default date is provided to the form element, it is magically enabled by default in the
-            // MoodleQuickForm_date_time_selector class, otherwise it's disabled by default.
-            if (get_config('moodlecourse', 'courseenddateenabled')) {
-                // At this stage (this is called from definition_after_data) course data is already set as default.
-                // We can not overwrite what is in the database.
-                $mform->setDefault('enddate', $this->get_default_course_enddate($mform));
-            }
-        }
-
-        return $elements;
-    }
-
-    /**
-     * Override if you need to perform some extra validation of the format options
-     *
-     * @param array $data array of ("fieldname"=>value) of submitted data
-     * @param array $files array of uploaded files "element_name"=>tmp_file_path
-     * @param array $errors errors already discovered in edit form validation
-     * @return array of "element_name"=>"error_description" if there are errors,
-     *         or an empty array if everything is OK.
-     *         Do not repeat errors from $errors param here
-     */
-    public function edit_form_validation($data, $files, $errors) {
-        return array();
-    }
-
-    /**
-     * Prepares values of course or section format options before storing them in DB
-     *
-     * If an option has invalid value it is not returned
-     *
-     * @param array $rawdata associative array of the proposed course/section format options
-     * @param int|null $sectionid null if it is course format option
-     * @return array array of options that have valid values
-     */
-    protected function validate_format_options(array $rawdata, int $sectionid = null) : array {
-        if (!$sectionid) {
-            $allformatoptions = $this->course_format_options(true);
-        } else {
-            $allformatoptions = $this->section_format_options(true);
-        }
-        $data = array_intersect_key($rawdata, $allformatoptions);
-        foreach ($data as $key => $value) {
-            $option = $allformatoptions[$key] + ['type' => PARAM_RAW, 'element_type' => null, 'element_attributes' => [[]]];
-            $data[$key] = clean_param($value, $option['type']);
-            if ($option['element_type'] === 'select' && !array_key_exists($data[$key], $option['element_attributes'][0])) {
-                // Value invalid for select element, skip.
-                unset($data[$key]);
-            }
-        }
-        return $data;
-    }
-
-    /**
-     * Validates format options for the course
-     *
-     * @param array $data data to insert/update
-     * @return array array of options that have valid values
-     */
-    public function validate_course_format_options(array $data) : array {
-        return $this->validate_format_options($data);
-    }
-
-    /**
-     * Updates format options for a course or section
-     *
-     * If $data does not contain property with the option name, the option will not be updated
-     *
-     * @param stdClass|array $data return value from {@link moodleform::get_data()} or array with data
-     * @param null|int null if these are options for course or section id (course_sections.id)
-     *     if these are options for section
-     * @return bool whether there were any changes to the options values
-     */
-    protected function update_format_options($data, $sectionid = null) {
-        global $DB;
-        $data = $this->validate_format_options((array)$data, $sectionid);
-        if (!$sectionid) {
-            $allformatoptions = $this->course_format_options();
-            $sectionid = 0;
-        } else {
-            $allformatoptions = $this->section_format_options();
-        }
-        if (empty($allformatoptions)) {
-            // nothing to update anyway
-            return false;
-        }
-        $defaultoptions = array();
-        $cached = array();
-        foreach ($allformatoptions as $key => $option) {
-            $defaultoptions[$key] = null;
-            if (array_key_exists('default', $option)) {
-                $defaultoptions[$key] = $option['default'];
-            }
-            $cached[$key] = ($sectionid === 0 || !empty($option['cache']));
-        }
-        $records = $DB->get_records('course_format_options',
-                array('courseid' => $this->courseid,
-                      'format' => $this->format,
-                      'sectionid' => $sectionid
-                    ), '', 'name,id,value');
-        $changed = $needrebuild = false;
-        foreach ($defaultoptions as $key => $value) {
-            if (isset($records[$key])) {
-                if (array_key_exists($key, $data) && $records[$key]->value !== $data[$key]) {
-                    $DB->set_field('course_format_options', 'value',
-                            $data[$key], array('id' => $records[$key]->id));
-                    $changed = true;
-                    $needrebuild = $needrebuild || $cached[$key];
-                }
-            } else {
-                if (array_key_exists($key, $data) && $data[$key] !== $value) {
-                    $newvalue = $data[$key];
-                    $changed = true;
-                    $needrebuild = $needrebuild || $cached[$key];
-                } else {
-                    $newvalue = $value;
-                    // we still insert entry in DB but there are no changes from user point of
-                    // view and no need to call rebuild_course_cache()
-                }
-                $DB->insert_record('course_format_options', array(
-                    'courseid' => $this->courseid,
-                    'format' => $this->format,
-                    'sectionid' => $sectionid,
-                    'name' => $key,
-                    'value' => $newvalue
-                ));
-            }
-        }
-        if ($needrebuild) {
-            rebuild_course_cache($this->courseid, true);
-        }
-        if ($changed) {
-            // reset internal caches
-            if (!$sectionid) {
-                $this->course = false;
-            }
-            unset($this->formatoptions[$sectionid]);
-        }
-        return $changed;
-    }
-
-    /**
-     * Updates format options for a course
-     *
-     * If $data does not contain property with the option name, the option will not be updated
-     *
-     * @param stdClass|array $data return value from {@link moodleform::get_data()} or array with data
-     * @param stdClass $oldcourse if this function is called from {@link update_course()}
-     *     this object contains information about the course before update
-     * @return bool whether there were any changes to the options values
-     */
-    public function update_course_format_options($data, $oldcourse = null) {
-        return $this->update_format_options($data);
-    }
-
-    /**
-     * Updates format options for a section
-     *
-     * Section id is expected in $data->id (or $data['id'])
-     * If $data does not contain property with the option name, the option will not be updated
-     *
-     * @param stdClass|array $data return value from {@link moodleform::get_data()} or array with data
-     * @return bool whether there were any changes to the options values
-     */
-    public function update_section_format_options($data) {
-        $data = (array)$data;
-        return $this->update_format_options($data, $data['id']);
-    }
-
-    /**
-     * Return an instance of moodleform to edit a specified section
-     *
-     * Default implementation returns instance of editsection_form that automatically adds
-     * additional fields defined in {@link format_base::section_format_options()}
-     *
-     * Format plugins may extend editsection_form if they want to have custom edit section form.
-     *
-     * @param mixed $action the action attribute for the form. If empty defaults to auto detect the
-     *              current url. If a moodle_url object then outputs params as hidden variables.
-     * @param array $customdata the array with custom data to be passed to the form
-     *     /course/editsection.php passes section_info object in 'cs' field
-     *     for filling availability fields
-     * @return moodleform
-     */
-    public function editsection_form($action, $customdata = array()) {
-        global $CFG;
-        require_once($CFG->dirroot. '/course/editsection_form.php');
-        $context = context_course::instance($this->courseid);
-        if (!array_key_exists('course', $customdata)) {
-            $customdata['course'] = $this->get_course();
-        }
-        return new editsection_form($action, $customdata);
-    }
-
-    /**
-     * Allows course format to execute code on moodle_page::set_course()
-     *
-     * @param moodle_page $page instance of page calling set_course
-     */
-    public function page_set_course(moodle_page $page) {
-    }
-
-    /**
-     * Allows course format to execute code on moodle_page::set_cm()
-     *
-     * Current module can be accessed as $page->cm (returns instance of cm_info)
-     *
-     * @param moodle_page $page instance of page calling set_cm
-     */
-    public function page_set_cm(moodle_page $page) {
-    }
-
-    /**
-     * Course-specific information to be output on any course page (usually above navigation bar)
-     *
-     * Example of usage:
-     * define
-     * class format_FORMATNAME_XXX implements renderable {}
-     *
-     * create format renderer in course/format/FORMATNAME/renderer.php, define rendering function:
-     * class format_FORMATNAME_renderer extends plugin_renderer_base {
-     *     protected function render_format_FORMATNAME_XXX(format_FORMATNAME_XXX $xxx) {
-     *         return html_writer::tag('div', 'This is my header/footer');
-     *     }
-     * }
-     *
-     * Return instance of format_FORMATNAME_XXX in this function, the appropriate method from
-     * plugin renderer will be called
-     *
-     * @return null|renderable null for no output or object with data for plugin renderer
-     */
-    public function course_header() {
-        return null;
-    }
-
-    /**
-     * Course-specific information to be output on any course page (usually in the beginning of
-     * standard footer)
-     *
-     * See {@link format_base::course_header()} for usage
-     *
-     * @return null|renderable null for no output or object with data for plugin renderer
-     */
-    public function course_footer() {
-        return null;
-    }
-
-    /**
-     * Course-specific information to be output immediately above content on any course page
-     *
-     * See {@link format_base::course_header()} for usage
-     *
-     * @return null|renderable null for no output or object with data for plugin renderer
-     */
-    public function course_content_header() {
-        return null;
-    }
-
-    /**
-     * Course-specific information to be output immediately below content on any course page
-     *
-     * See {@link format_base::course_header()} for usage
-     *
-     * @return null|renderable null for no output or object with data for plugin renderer
-     */
-    public function course_content_footer() {
-        return null;
-    }
-
-    /**
-     * Returns instance of page renderer used by this plugin
-     *
-     * @param moodle_page $page
-     * @return renderer_base
-     */
-    public function get_renderer(moodle_page $page) {
-        return $page->get_renderer('format_'. $this->get_format());
-    }
-
-    /**
-     * Returns true if the specified section is current
-     *
-     * By default we analyze $course->marker
-     *
-     * @param int|stdClass|section_info $section
-     * @return bool
-     */
-    public function is_section_current($section) {
-        if (is_object($section)) {
-            $sectionnum = $section->section;
-        } else {
-            $sectionnum = $section;
-        }
-        return ($sectionnum && ($course = $this->get_course()) && $course->marker == $sectionnum);
-    }
-
-    /**
-     * Allows to specify for modinfo that section is not available even when it is visible and conditionally available.
-     *
-     * Note: affected user can be retrieved as: $section->modinfo->userid
-     *
-     * Course format plugins can override the method to change the properties $available and $availableinfo that were
-     * calculated by conditional availability.
-     * To make section unavailable set:
-     *     $available = false;
-     * To make unavailable section completely hidden set:
-     *     $availableinfo = '';
-     * To make unavailable section visible with availability message set:
-     *     $availableinfo = get_string('sectionhidden', 'format_xxx');
-     *
-     * @param section_info $section
-     * @param bool $available the 'available' propery of the section_info as it was evaluated by conditional availability.
-     *     Can be changed by the method but 'false' can not be overridden by 'true'.
-     * @param string $availableinfo the 'availableinfo' propery of the section_info as it was evaluated by conditional availability.
-     *     Can be changed by the method
-     */
-    public function section_get_available_hook(section_info $section, &$available, &$availableinfo) {
-    }
-
-    /**
-     * Whether this format allows to delete sections
-     *
-     * If format supports deleting sections it is also recommended to define language string
-     * 'deletesection' inside the format.
-     *
-     * Do not call this function directly, instead use {@link course_can_delete_section()}
-     *
-     * @param int|stdClass|section_info $section
-     * @return bool
-     */
-    public function can_delete_section($section) {
-        return false;
-    }
-
-    /**
-     * Deletes a section
-     *
-     * Do not call this function directly, instead call {@link course_delete_section()}
-     *
-     * @param int|stdClass|section_info $section
-     * @param bool $forcedeleteifnotempty if set to false section will not be deleted if it has modules in it.
-     * @return bool whether section was deleted
-     */
-    public function delete_section($section, $forcedeleteifnotempty = false) {
-        global $DB;
-        if (!$this->uses_sections()) {
-            // Not possible to delete section if sections are not used.
-            return false;
-        }
-        if (!is_object($section)) {
-            $section = $DB->get_record('course_sections', array('course' => $this->get_courseid(), 'section' => $section),
-                'id,section,sequence,summary');
-        }
-        if (!$section || !$section->section) {
-            // Not possible to delete 0-section.
-            return false;
-        }
-
-        if (!$forcedeleteifnotempty && (!empty($section->sequence) || !empty($section->summary))) {
-            return false;
-        }
-
-        $course = $this->get_course();
-
-        // Remove the marker if it points to this section.
-        if ($section->section == $course->marker) {
-            course_set_marker($course->id, 0);
-        }
-
-        $lastsection = $DB->get_field_sql('SELECT max(section) from {course_sections}
-                            WHERE course = ?', array($course->id));
-
-        // Find out if we need to descrease the 'numsections' property later.
-        $courseformathasnumsections = array_key_exists('numsections',
-            $this->get_format_options());
-        $decreasenumsections = $courseformathasnumsections && ($section->section <= $course->numsections);
-
-        // Move the section to the end.
-        move_section_to($course, $section->section, $lastsection, true);
-
-        // Delete all modules from the section.
-        foreach (preg_split('/,/', $section->sequence, -1, PREG_SPLIT_NO_EMPTY) as $cmid) {
-            course_delete_module($cmid);
-        }
-
-        // Delete section and it's format options.
-        $DB->delete_records('course_format_options', array('sectionid' => $section->id));
-        $DB->delete_records('course_sections', array('id' => $section->id));
-        rebuild_course_cache($course->id, true);
-
-        // Delete section summary files.
-        $context = \context_course::instance($course->id);
-        $fs = get_file_storage();
-        $fs->delete_area_files($context->id, 'course', 'section', $section->id);
-
-        // Descrease 'numsections' if needed.
-        if ($decreasenumsections) {
-            $this->update_course_format_options(array('numsections' => $course->numsections - 1));
-        }
-
-        return true;
-    }
-
-    /**
-     * Prepares the templateable object to display section name
-     *
-     * @param \section_info|\stdClass $section
-     * @param bool $linkifneeded
-     * @param bool $editable
-     * @param null|lang_string|string $edithint
-     * @param null|lang_string|string $editlabel
-     * @return \core\output\inplace_editable
-     */
-    public function inplace_editable_render_section_name($section, $linkifneeded = true,
-                                                         $editable = null, $edithint = null, $editlabel = null) {
-        global $USER, $CFG;
-        require_once($CFG->dirroot.'/course/lib.php');
-
-        if ($editable === null) {
-            $editable = !empty($USER->editing) && has_capability('moodle/course:update',
-                    context_course::instance($section->course));
-        }
-
-        $displayvalue = $title = get_section_name($section->course, $section);
-        if ($linkifneeded) {
-            // Display link under the section name if the course format setting is to display one section per page.
-            $url = course_get_url($section->course, $section->section, array('navigation' => true));
-            if ($url) {
-                $displayvalue = html_writer::link($url, $title);
-            }
-            $itemtype = 'sectionname';
-        } else {
-            // If $linkifneeded==false, we never display the link (this is used when rendering the section header).
-            // Itemtype 'sectionnamenl' (nl=no link) will tell the callback that link should not be rendered -
-            // there is no other way callback can know where we display the section name.
-            $itemtype = 'sectionnamenl';
-        }
-        if (empty($edithint)) {
-            $edithint = new lang_string('editsectionname');
-        }
-        if (empty($editlabel)) {
-            $editlabel = new lang_string('newsectionname', '', $title);
-        }
-
-        return new \core\output\inplace_editable('format_' . $this->format, $itemtype, $section->id, $editable,
-            $displayvalue, $section->name, $edithint, $editlabel);
-    }
-
-    /**
-     * Updates the value in the database and modifies this object respectively.
-     *
-     * ALWAYS check user permissions before performing an update! Throw exceptions if permissions are not sufficient
-     * or value is not legit.
-     *
-     * @param stdClass $section
-     * @param string $itemtype
-     * @param mixed $newvalue
-     * @return \core\output\inplace_editable
-     */
-    public function inplace_editable_update_section_name($section, $itemtype, $newvalue) {
-        if ($itemtype === 'sectionname' || $itemtype === 'sectionnamenl') {
-            $context = context_course::instance($section->course);
-            external_api::validate_context($context);
-            require_capability('moodle/course:update', $context);
-
-            $newtitle = clean_param($newvalue, PARAM_TEXT);
-            if (strval($section->name) !== strval($newtitle)) {
-                course_update_section($section->course, $section, array('name' => $newtitle));
-            }
-            return $this->inplace_editable_render_section_name($section, ($itemtype === 'sectionname'), true);
-        }
-    }
-
-
-    /**
-     * Returns the default end date value based on the start date.
-     *
-     * This is the default implementation for course formats, it is based on
-     * moodlecourse/courseduration setting. Course formats like format_weeks for
-     * example can overwrite this method and return a value based on their internal options.
-     *
-     * @param moodleform $mform
-     * @param array $fieldnames The form - field names mapping.
-     * @return int
-     */
-    public function get_default_course_enddate($mform, $fieldnames = array()) {
-
-        if (empty($fieldnames)) {
-            $fieldnames = array('startdate' => 'startdate');
-        }
-
-        $startdate = $this->get_form_start_date($mform, $fieldnames);
-        $courseduration = intval(get_config('moodlecourse', 'courseduration'));
-        if (!$courseduration) {
-            // Default, it should be already set during upgrade though.
-            $courseduration = YEARSECS;
-        }
-
-        return $startdate + $courseduration;
-    }
-
-    /**
-     * Indicates whether the course format supports the creation of the Announcements forum.
-     *
-     * For course format plugin developers, please override this to return true if you want the Announcements forum
-     * to be created upon course creation.
-     *
-     * @return bool
-     */
-    public function supports_news() {
-        // For backwards compatibility, check if default blocks include the news_items block.
-        $defaultblocks = $this->get_default_blocks();
-        foreach ($defaultblocks as $blocks) {
-            if (in_array('news_items', $blocks)) {
-                return true;
-            }
-        }
-        // Return false by default.
-        return false;
-    }
-
-    /**
-     * Get the start date value from the course settings page form.
-     *
-     * @param moodleform $mform
-     * @param array $fieldnames The form - field names mapping.
-     * @return int
-     */
-    protected function get_form_start_date($mform, $fieldnames) {
-        $startdate = $mform->getElementValue($fieldnames['startdate']);
-        return $mform->getElement($fieldnames['startdate'])->exportValue($startdate);
-    }
-
-    /**
-     * Returns whether this course format allows the activity to
-     * have "triple visibility state" - visible always, hidden on course page but available, hidden.
-     *
-     * @param stdClass|cm_info $cm course module (may be null if we are displaying a form for adding a module)
-     * @param stdClass|section_info $section section where this module is located or will be added to
-     * @return bool
-     */
-    public function allow_stealth_module_visibility($cm, $section) {
-        return false;
-    }
-
-    /**
-     * Callback used in WS core_course_edit_section when teacher performs an AJAX action on a section (show/hide)
-     *
-     * Access to the course is already validated in the WS but the callback has to make sure
-     * that particular action is allowed by checking capabilities
-     *
-     * Course formats should register
-     *
-     * @param stdClass|section_info $section
-     * @param string $action
-     * @param int $sr
-     * @return null|array|stdClass any data for the Javascript post-processor (must be json-encodeable)
-     */
-    public function section_action($section, $action, $sr) {
-        global $PAGE;
-        if (!$this->uses_sections() || !$section->section) {
-            // No section actions are allowed if course format does not support sections.
-            // No actions are allowed on the 0-section by default (overwrite in course format if needed).
-            throw new moodle_exception('sectionactionnotsupported', 'core', null, s($action));
-        }
-
-        $course = $this->get_course();
-        $coursecontext = context_course::instance($course->id);
-        switch($action) {
-            case 'hide':
-            case 'show':
-                require_capability('moodle/course:sectionvisibility', $coursecontext);
-                $visible = ($action === 'hide') ? 0 : 1;
-                course_update_section($course, $section, array('visible' => $visible));
-                break;
-            default:
-                throw new moodle_exception('sectionactionnotsupported', 'core', null, s($action));
-        }
-
-        $modules = [];
-
-        $modinfo = get_fast_modinfo($course);
-        $coursesections = $modinfo->sections;
-        if (array_key_exists($section->section, $coursesections)) {
-            $courserenderer = $PAGE->get_renderer('core', 'course');
-            $completioninfo = new completion_info($course);
-            foreach ($coursesections[$section->section] as $cmid) {
-                $cm = $modinfo->get_cm($cmid);
-                $modules[] = $courserenderer->course_section_cm_list_item($course, $completioninfo, $cm, $sr);
-            }
-        }
-
-        return ['modules' => $modules];
-    }
-
-    /**
-     * Return the plugin config settings for external functions,
-     * in some cases the configs will need formatting or be returned only if the current user has some capabilities enabled.
-     *
-     * @return array the list of configs
-     * @since Moodle 3.5
-     */
-    public function get_config_for_external() {
-        return array();
-    }
+    return course_format::instance($courseorid);
 }
 
 /**
@@ -1335,7 +44,7 @@ abstract class format_base {
  * @copyright  2012 Marina Glancy
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class format_site extends format_base {
+class format_site extends course_format {
 
     /**
      * Returns the display name of the given section that the course prefers.
@@ -1399,4 +108,27 @@ class format_site extends format_base {
     public function allow_stealth_module_visibility($cm, $section) {
         return true;
     }
+
+    /**
+     * Returns instance of page renderer used by the site page
+     *
+     * @param moodle_page $page the current page
+     * @return renderer_base
+     */
+    public function get_renderer(moodle_page $page) {
+        global $CFG;
+        if (!class_exists('format_site_renderer')) {
+            require_once($CFG->dirroot.'/course/format/renderer.php');
+        }
+        return new format_site_renderer($page, null);
+    }
+
+    /**
+     * Site format uses only section 1.
+     *
+     * @return int
+     */
+    public function get_section_number(): int {
+        return 1;
+    }
 }
diff --git a/course/format/renderer.php b/course/format/renderer.php
index b5884c36c5b..3fe14315bf8 100644
--- a/course/format/renderer.php
+++ b/course/format/renderer.php
@@ -25,6 +25,10 @@
 
 defined('MOODLE_INTERNAL') || die();
 
+use core_course\course_format;
+
+global $CFG;
+require_once($CFG->dirroot. '/course/renderer.php');
 
 /**
  * This is a convenience renderer which can be used by section based formats
@@ -36,13 +40,22 @@ defined('MOODLE_INTERNAL') || die();
  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  * @since Moodle 2.3
  */
-abstract class format_section_renderer_base extends plugin_renderer_base {
+abstract class format_section_renderer_base extends core_course_renderer {
 
-    /** @var core_course_renderer contains instance of core course renderer */
+    /**
+     * @var core_course_renderer contains an instance of core course renderer
+     * @deprecated since 4.0 - use $this to access course renderer methods
+     */
     protected $courserenderer;
 
     /**
-     * Constructor method, calls the parent constructor
+     * Constructor method, calls the parent constructor.
+     *
+     * @deprecated since 4.0
+     *
+     * Note: this method exists only for compatibilitiy with legacy course formats. Legacy formats
+     * depends on $this->courserenderer to access the course renderer methods. Since Moodle 4.0
+     * format_section_renderer_base extends core_course_renderer and all metdhos can be used directly from $this.
      *
      * @param moodle_page $page
      * @param string $target one of rendering target constants
@@ -53,22 +66,46 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     }
 
     /**
-     * Generate the starting container html for a list of sections
-     * @return string HTML to output.
+     * Renders the provided widget and returns the HTML to display it.
+     *
+     * Course format templates uses a similar subfolder structure to the renderable classes.
+     * This method find out the specific template for a course widget. That's the reason why
+     * this render method is different from the normal plugin renderer one.
+     *
+     * course format templatables can be rendered using the core_course/local/* templates.
+     * Format plugins are free to override the default template location using render_xxx methods as usual.
+     *
+     * @param renderable $widget instance with renderable interface
+     * @return string the widget HTML
      */
-    abstract protected function start_section_list();
+    public function render(renderable $widget) {
+        global $CFG;
+        $fullpath = str_replace('\\', '/', get_class($widget));
+        $classparts = explode('/', $fullpath);
+        // Strip namespaces.
+        $classname = array_pop($classparts);
+        // Remove _renderable suffixes.
+        $classname = preg_replace('/_renderable$/', '', $classname);
 
-    /**
-     * Generate the closing container html for a list of sections
-     * @return string HTML to output.
-     */
-    abstract protected function end_section_list();
+        $rendermethod = 'render_' . $classname;
+        if (method_exists($this, $rendermethod)) {
+            return $this->$rendermethod($widget);
+        }
+        // Check for special course format templatables.
+        if ($widget instanceof templatable) {
+            // Templatables from both core_course\output\xxx_format\* and format_xxx\output\xxx_format\*
+            // use core_crouse/local/xxx_format templates by default.
+            $specialrenderers = '/^(?<component>core_course|format_.+)\/output\/(?<template>.+_format.*)$/';
+            $matches = null;
 
-    /**
-     * Generate the title for this section page
-     * @return string the page title
-     */
-    abstract protected function page_title();
+            if (preg_match($specialrenderers, $fullpath, $matches)) {
+                $data = $widget->export_for_template($this);
+                return $this->render_from_template('core_course/local/'.$matches['template'], $data);
+            }
+        }
+        // If nothing works, let the parent class decide.
+        return parent::render($widget);
+    }
 
     /**
      * Generate the section title, wraps it in a link to the section page if page is to be displayed on a separate page
@@ -97,15 +134,53 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
         return get_section_name($course, $section);
     }
 
+    /**
+     * Get the updated rendered version of a cm list item.
+     *
+     * This method is used when an activity is duplicated or copied in on the client side without refreshing the page.
+     * It replaces the course renderer course_section_cm_list_item method but it's scope is different.
+     * Note that the previous method is used every time an activity is rendered, independent of it is the initial page
+     * loading or an Ajax update. In this case, course_section_updated_cm_item will only be used when the course editor
+     * requires to get an updated cm item HTML to perform partial page refresh. It will be used for suporting the course
+     * editor webservices.
+     *
+     * By default, the template used for update a cm_item is the same as when it renders initially, but format plugins are
+     * free to override this methos to provide extra affects or so.
+     *
+     * @param course_format $format the course format
+     * @param section_info $section the section info
+     * @param cm_info $cm the course module ionfo
+     * @param array $displayoptions optional extra display options
+     */
+    public function course_section_updated_cm_item(
+            course_format $format,
+            section_info $section,
+            cm_info $cm,
+            array $displayoptions = []) {
+
+        $cmitemclass = $format->get_output_classname('section_format\cmitem');
+        $cmitem = new $cmitemclass($format, $section, $cm, $displayoptions);
+        return $this->render($cmitem);
+    }
+
     /**
      * Generate the edit control action menu
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * The section edit controls are now part of the main section_format output and does
+     * not use renderer methods anymore.
+     *
      * @param array $controls The edit control items from section_edit_control_items
-     * @param stdClass $course The course entry from DB
+     * @param stdClass $course The course entry from DB (not used)
      * @param stdClass $section The course_section entry from DB
      * @return string HTML to output.
      */
     protected function section_edit_control_menu($controls, $course, $section) {
+        debugging('section_edit_control_menu() can not be used anymore. Please use ' .
+            'core_course\output\section_format to render a section. In case you need to modify those controls ' .
+            'override core_course\output\section_format\controlmenu in your format plugin.', DEBUG_DEVELOPER);
+
         $o = "";
         if (!empty($controls)) {
             $menu = new action_menu();
@@ -137,12 +212,22 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * Generate the content to displayed on the right part of a section
      * before course modules are included
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * Spatial references like "left" or "right" are limiting the way formats and themes can
+     * extend courses. The elements from this method are now included in the section_format
+     * output components.
+     *
      * @param stdClass $section The course_section entry from DB
      * @param stdClass $course The course entry from DB
      * @param bool $onsectionpage true if being printed on a section page
      * @return string HTML to output.
      */
     protected function section_right_content($section, $course, $onsectionpage) {
+
+        debugging('section_right_content() can not be used anymore. Please use ' .
+            'core_course\output\section_format to render a section.', DEBUG_DEVELOPER);
+
         $o = $this->output->spacer();
 
         $controls = $this->section_edit_control_items($course, $section, $onsectionpage);
@@ -155,12 +240,22 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * Generate the content to displayed on the left part of a section
      * before course modules are included
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * Spatial references like "left" or "right" are limiting the way formats and themes can
+     * extend courses. The elements from this method are now included in the section_format
+     * output components.
+     *
      * @param stdClass $section The course_section entry from DB
      * @param stdClass $course The course entry from DB
      * @param bool $onsectionpage true if being printed on a section page
      * @return string HTML to output.
      */
     protected function section_left_content($section, $course, $onsectionpage) {
+
+        debugging('section_left_content() can not be used anymore. Please use ' .
+            'core_course\output\section_format to render a section.', DEBUG_DEVELOPER);
+
         $o = '';
 
         if ($section->section != 0) {
@@ -177,6 +272,11 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * Generate the display of the header part of a section before
      * course modules are included
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param stdClass $section The course_section entry from DB
      * @param stdClass $course The course entry from DB
      * @param bool $onsectionpage true if being printed on a single-section page
@@ -184,8 +284,11 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * @return string HTML to output.
      */
     protected function section_header($section, $course, $onsectionpage, $sectionreturn=null) {
+        debugging('section_header() is deprecated. Please use ' .
+        'core_course\output\section_format to render a section or core_course\output\section_format\header '.
+        'to print ony the header.', DEBUG_DEVELOPER);
+
         $o = '';
-        $currenttext = '';
         $sectionstyle = '';
 
         if ($section->section != 0) {
@@ -208,11 +311,11 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
         ]);
 
         $leftcontent = $this->section_left_content($section, $course, $onsectionpage);
-        $o.= html_writer::tag('div', $leftcontent, array('class' => 'left side'));
+        $o .= html_writer::tag('div', $leftcontent, array('class' => 'left side'));
 
         $rightcontent = $this->section_right_content($section, $course, $onsectionpage);
-        $o.= html_writer::tag('div', $rightcontent, array('class' => 'right side'));
-        $o.= html_writer::start_tag('div', array('class' => 'content'));
+        $o .= html_writer::tag('div', $rightcontent, array('class' => 'right side'));
+        $o .= html_writer::start_tag('div', array('class' => 'content'));
 
         // When not on a section page, we display the section titles except the general section if null
         $hasnamenotsecpg = (!$onsectionpage && ($section->section != 0 || !is_null($section->name)));
@@ -242,14 +345,23 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     }
 
     /**
-     * Generate the display of the footer part of a section
+     * Generate the display of the footer part of a section.
+     *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is integrated into section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
      *
      * @return string HTML to output.
      */
     protected function section_footer() {
-        $o = html_writer::end_tag('div');
-        $o.= html_writer::end_tag('li');
 
+        debugging('section_footer() is deprecated. Please use ' .
+            'core_course\output\section_format to render individual sections or .'.
+            'core_course\output\course_format to render the full course', DEBUG_DEVELOPER);
+
+        $o = html_writer::end_tag('div');
+        $o .= html_writer::end_tag('li');
         return $o;
     }
 
@@ -264,133 +376,53 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Generate the edit control items of a section
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param stdClass $course The course entry from DB
      * @param stdClass $section The course_section entry from DB
      * @param bool $onsectionpage true if being printed on a section page
      * @return array of edit control items
      */
     protected function section_edit_control_items($course, $section, $onsectionpage = false) {
-        if (!$this->page->user_is_editing()) {
-            return array();
+        debugging('section_edit_control_items() is deprecated, please use or extend' .
+            'core_course\output\section_format\controlmenu instead (like topics format does).', DEBUG_DEVELOPER);
+
+        $format = course_get_format($course);
+        $modinfo = $format->get_modinfo();
+
+        if ($onsectionpage) {
+            $format->set_section_number($section->section);
         }
 
-        $sectionreturn = $onsectionpage ? $section->section : null;
+        // We need a section_info object, not a record.
+        $section = $modinfo->get_section_info($section->section);
 
-        $coursecontext = context_course::instance($course->id);
-        $numsections = course_get_format($course)->get_last_section_number();
-        $isstealth = $section->section > $numsections;
-
-        $baseurl = course_get_url($course, $sectionreturn);
-        $baseurl->param('sesskey', sesskey());
-
-        $controls = array();
-
-        if (!$isstealth && has_capability('moodle/course:update', $coursecontext)) {
-            if ($section->section > 0
-                && get_string_manager()->string_exists('editsection', 'format_'.$course->format)) {
-                $streditsection = get_string('editsection', 'format_'.$course->format);
-            } else {
-                $streditsection = get_string('editsection');
-            }
-
-            $controls['edit'] = array(
-                'url'   => new moodle_url('/course/editsection.php', array('id' => $section->id, 'sr' => $sectionreturn)),
-                'icon' => 'i/settings',
-                'name' => $streditsection,
-                'pixattr' => array('class' => ''),
-                'attr' => array('class' => 'icon edit'));
-        }
-
-        if ($section->section) {
-            $url = clone($baseurl);
-            if (!$isstealth) {
-                if (has_capability('moodle/course:sectionvisibility', $coursecontext)) {
-                    if ($section->visible) { // Show the hide/show eye.
-                        $strhidefromothers = get_string('hidefromothers', 'format_'.$course->format);
-                        $url->param('hide', $section->section);
-                        $controls['visiblity'] = array(
-                            'url' => $url,
-                            'icon' => 'i/hide',
-                            'name' => $strhidefromothers,
-                            'pixattr' => array('class' => ''),
-                            'attr' => array('class' => 'icon editing_showhide',
-                                'data-sectionreturn' => $sectionreturn, 'data-action' => 'hide'));
-                    } else {
-                        $strshowfromothers = get_string('showfromothers', 'format_'.$course->format);
-                        $url->param('show',  $section->section);
-                        $controls['visiblity'] = array(
-                            'url' => $url,
-                            'icon' => 'i/show',
-                            'name' => $strshowfromothers,
-                            'pixattr' => array('class' => ''),
-                            'attr' => array('class' => 'icon editing_showhide',
-                                'data-sectionreturn' => $sectionreturn, 'data-action' => 'show'));
-                    }
-                }
-
-                if (!$onsectionpage) {
-                    if (has_capability('moodle/course:movesections', $coursecontext)) {
-                        $url = clone($baseurl);
-                        if ($section->section > 1) { // Add a arrow to move section up.
-                            $url->param('section', $section->section);
-                            $url->param('move', -1);
-                            $strmoveup = get_string('moveup');
-                            $controls['moveup'] = array(
-                                'url' => $url,
-                                'icon' => 'i/up',
-                                'name' => $strmoveup,
-                                'pixattr' => array('class' => ''),
-                                'attr' => array('class' => 'icon moveup'));
-                        }
-
-                        $url = clone($baseurl);
-                        if ($section->section < $numsections) { // Add a arrow to move section down.
-                            $url->param('section', $section->section);
-                            $url->param('move', 1);
-                            $strmovedown = get_string('movedown');
-                            $controls['movedown'] = array(
-                                'url' => $url,
-                                'icon' => 'i/down',
-                                'name' => $strmovedown,
-                                'pixattr' => array('class' => ''),
-                                'attr' => array('class' => 'icon movedown'));
-                        }
-                    }
-                }
-            }
-
-            if (course_can_delete_section($course, $section)) {
-                if (get_string_manager()->string_exists('deletesection', 'format_'.$course->format)) {
-                    $strdelete = get_string('deletesection', 'format_'.$course->format);
-                } else {
-                    $strdelete = get_string('deletesection');
-                }
-                $url = new moodle_url('/course/editsection.php', array(
-                    'id' => $section->id,
-                    'sr' => $sectionreturn,
-                    'delete' => 1,
-                    'sesskey' => sesskey()));
-                $controls['delete'] = array(
-                    'url' => $url,
-                    'icon' => 'i/delete',
-                    'name' => $strdelete,
-                    'pixattr' => array('class' => ''),
-                    'attr' => array('class' => 'icon editing_delete'));
-            }
-        }
-
-        return $controls;
+        $widgetclass = $format->get_output_classname('section_format\\controlmenu');
+        $widget = new $widgetclass($format, $section);
+        return $widget->section_control_items();
     }
 
     /**
      * Generate a summary of a section for display on the 'course index page'
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param stdClass $section The course_section entry from DB
      * @param stdClass $course The course entry from DB
      * @param array    $mods (argument not used)
      * @return string HTML to output.
      */
     protected function section_summary($section, $course, $mods) {
+        debugging('section_summary() is deprecated. Please use ' .
+            'core_course\output\section_format to render sections. If you need to modify those summary, extend ' .
+            'core_course\output\section_format\summary in your format plugin.', DEBUG_DEVELOPER);
+
         $classattr = 'section main section-summary clearfix';
         $linkclasses = '';
 
@@ -418,12 +450,12 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
 
         if ($section->uservisible) {
             $title = html_writer::tag('a', $title,
-                    array('href' => course_get_url($course, $section->section), 'class' => $linkclasses));
+                array('href' => course_get_url($course, $section->section), 'class' => $linkclasses));
         }
         $o .= $this->output->heading($title, 3, 'section-title');
 
         $o .= $this->section_availability($section);
-        $o.= html_writer::start_tag('div', array('class' => 'summarytext'));
+        $o .= html_writer::start_tag('div', array('class' => 'summarytext'));
 
         if ($section->uservisible || $section->visible) {
             // Show summary if section is available or has availability restriction information.
@@ -431,8 +463,8 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
             // "Hidden sections are shown in collapsed form".
             $o .= $this->format_summary_text($section);
         }
-        $o.= html_writer::end_tag('div');
-        $o.= $this->section_activity_summary($section, $course, null);
+        $o .= html_writer::end_tag('div');
+        $o .= $this->section_activity_summary($section, $course, null);
 
         $o .= html_writer::end_tag('div');
         $o .= html_writer::end_tag('li');
@@ -443,72 +475,26 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Generate a summary of the activites in a section
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param stdClass $section The course_section entry from DB
      * @param stdClass $course the course record from DB
      * @param array    $mods (argument not used)
      * @return string HTML to output.
      */
     protected function section_activity_summary($section, $course, $mods) {
-        $modinfo = get_fast_modinfo($course);
-        if (empty($modinfo->sections[$section->section])) {
-            return '';
-        }
 
-        // Generate array with count of activities in this section:
-        $sectionmods = array();
-        $total = 0;
-        $complete = 0;
-        $cancomplete = isloggedin() && !isguestuser();
-        $completioninfo = new completion_info($course);
-        foreach ($modinfo->sections[$section->section] as $cmid) {
-            $thismod = $modinfo->cms[$cmid];
+        debugging('section_activity_summary() is deprecated. Please use ' .
+            'core_course\output\section_format to render sections. If you need to modify those information, extend ' .
+            'core_course\output\section_format\cmsummary in your format plugin.', DEBUG_DEVELOPER);
 
-            if ($thismod->uservisible) {
-                if (isset($sectionmods[$thismod->modname])) {
-                    $sectionmods[$thismod->modname]['name'] = $thismod->modplural;
-                    $sectionmods[$thismod->modname]['count']++;
-                } else {
-                    $sectionmods[$thismod->modname]['name'] = $thismod->modfullname;
-                    $sectionmods[$thismod->modname]['count'] = 1;
-                }
-                if ($cancomplete && $completioninfo->is_enabled($thismod) != COMPLETION_TRACKING_NONE) {
-                    $total++;
-                    $completiondata = $completioninfo->get_data($thismod, true);
-                    if ($completiondata->completionstate == COMPLETION_COMPLETE ||
-                            $completiondata->completionstate == COMPLETION_COMPLETE_PASS) {
-                        $complete++;
-                    }
-                }
-            }
-        }
-
-        if (empty($sectionmods)) {
-            // No sections
-            return '';
-        }
-
-        // Output section activities summary:
-        $o = '';
-        $o.= html_writer::start_tag('div', array('class' => 'section-summary-activities pr-2 mdl-right'));
-        foreach ($sectionmods as $mod) {
-            $o.= html_writer::start_tag('span', array('class' => 'activity-count'));
-            $o.= $mod['name'].': '.$mod['count'];
-            $o.= html_writer::end_tag('span');
-        }
-        $o.= html_writer::end_tag('div');
-
-        // Output section completion data
-        if ($total > 0) {
-            $a = new stdClass;
-            $a->complete = $complete;
-            $a->total = $total;
-
-            $o.= html_writer::start_tag('div', array('class' => 'section-summary-activities pr-2 mdl-right'));
-            $o.= html_writer::tag('span', get_string('progresstotal', 'completion', $a), array('class' => 'activity-count'));
-            $o.= html_writer::end_tag('div');
-        }
-
-        return $o;
+        $format = course_get_format($course);
+        $widgetclass = $format->get_output_classname('section_format\\cmsummary');
+        $widget = new $widgetclass($format, $section);
+        $this->render($widget);
     }
 
     /**
@@ -521,49 +507,45 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * are going to be unavailable etc). This logic is the same as for
      * activities.
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param section_info $section The course_section entry from DB
      * @param bool $canviewhidden True if user can view hidden sections
      * @return string HTML to output
      */
     protected function section_availability_message($section, $canviewhidden) {
         global $CFG;
-        $o = '';
-        if (!$section->visible) {
-            if ($canviewhidden) {
-                $o .= $this->courserenderer->availability_info(get_string('hiddenfromstudents'), 'ishidden');
-            } else {
-                // We are here because of the setting "Hidden sections are shown in collapsed form".
-                // Student can not see the section contents but can see its name.
-                $o .= $this->courserenderer->availability_info(get_string('notavailable'), 'ishidden');
-            }
-        } else if (!$section->uservisible) {
-            if ($section->availableinfo) {
-                // Note: We only get to this function if availableinfo is non-empty,
-                // so there is definitely something to print.
-                $formattedinfo = \core_availability\info::format_info(
-                        $section->availableinfo, $section->course);
-                $o .= $this->courserenderer->availability_info($formattedinfo, 'isrestricted');
-            }
-        } else if ($canviewhidden && !empty($CFG->enableavailability)) {
-            // Check if there is an availability restriction.
-            $ci = new \core_availability\info_section($section);
-            $fullinfo = $ci->get_full_information();
-            if ($fullinfo) {
-                $formattedinfo = \core_availability\info::format_info(
-                        $fullinfo, $section->course);
-                $o .= $this->courserenderer->availability_info($formattedinfo, 'isrestricted isfullinfo');
-            }
-        }
-        return $o;
+
+        debugging('section_availability_message() is deprecated. Please use ' .
+            'core_course\output\section_format to render sections. If you need to modify this element, extend ' .
+            'core_course\output\section_format\availability in your format plugin.', DEBUG_DEVELOPER);
+
+        $course = $section->course;
+        $format = course_get_format($course);
+        $widgetclass = $format->get_output_classname('section_format\\availability');
+        $widget = new $widgetclass($format, $section);
+        $this->render($widget);
     }
 
     /**
      * Displays availability information for the section (hidden, not available unles, etc.)
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param section_info $section
      * @return string
      */
     public function section_availability($section) {
+        debugging('section_availability() is deprecated. Please use ' .
+            'core_course\output\section_format to render sections. If you need to modify this element, extend ' .
+            'core_course\output\section_format\availability in your format plugin.', DEBUG_DEVELOPER);
+
         $context = context_course::instance($section->course);
         $canviewhidden = has_capability('moodle/course:viewhiddensections', $context);
         return html_writer::div($this->section_availability_message($section, $canviewhidden), 'section_availability');
@@ -572,12 +554,18 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Show if something is on on the course clipboard (moving around)
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * While the non ajax course eidtion is still supported, the old clipboard will be
+     * emulated by core_course\output\format_section\cmlist.
+     *
      * @param stdClass $course The course entry from DB
      * @param int $sectionno The section number in the course which is being displayed
      * @return string HTML to output.
      */
     protected function course_activity_clipboard($course, $sectionno = null) {
         global $USER;
+        debugging('Non ajax course edition using course_activity_clipboard is not supported anymore.', DEBUG_DEVELOPER);
 
         $o = '';
         // If currently moving a file then show the current clipboard.
@@ -599,7 +587,12 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     }
 
     /**
-     * Generate next/previous section links for naviation
+     * Generate next/previous section links for naviation.
+     *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
      *
      * @param stdClass $course The course entry from DB
      * @param array $sections The course_sections entries from the DB
@@ -607,6 +600,11 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * @return array associative array with previous and next section link
      */
     protected function get_nav_links($course, $sections, $sectionno) {
+
+        debugging('get_nav_links() is deprecated. Please use ' .
+            'core_course\output\course_format to render a course. If you need to modify this element, extend ' .
+            'core_course\output\course_format\sectionnavigation in your format plugin.', DEBUG_DEVELOPER);
+
         // FIXME: This is really evil and should by using the navigation API.
         $course = course_get_format($course)->get_course();
         $canviewhidden = has_capability('moodle/course:viewhiddensections', context_course::instance($course->id))
@@ -648,10 +646,18 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Generate the header html of a stealth section
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param int $sectionno The section number in the course which is being displayed
      * @return string HTML to output.
      */
     protected function stealth_section_header($sectionno) {
+        debugging('stealth_section_header() is deprecated. Please use ' .
+        'core_course\output\section_format to render sections.', DEBUG_DEVELOPER);
+
         $o = '';
         $o .= html_writer::start_tag('li', [
             'id' => 'section-'.$sectionno,
@@ -675,9 +681,17 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Generate footer html of a stealth section
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @return string HTML to output.
      */
     protected function stealth_section_footer() {
+        debugging('stealth_section_footer() is deprecated. Please use ' .
+                'core_course\output\section_format to render sections.', DEBUG_DEVELOPER);
+
         $o = html_writer::end_tag('div');
         $o.= html_writer::end_tag('li');
         return $o;
@@ -716,6 +730,11 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Generate the html for the 'Jump to' menu on a single section page.
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
+     * This element is now a section_format output component and it is displayed using
+     * mustache templates instead of a renderer method.
+     *
      * @param stdClass $course The course entry from DB
      * @param array $sections The course_sections entries from the DB
      * @param $displaysection the current displayed section number.
@@ -723,7 +742,12 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * @return string HTML to output.
      */
     protected function section_nav_selection($course, $sections, $displaysection) {
-        global $CFG;
+
+        debugging('section_nav_selection() can not be used anymore. Please use ' .
+            'core_course\output\course_format to render a course. If you need to modify this element, extend ' .
+            'core_course\output\course_format\sectionnavigation or ' .
+            'core_course\output\course_format\sectionselector in your format plugin.', DEBUG_DEVELOPER);
+
         $o = '';
         $sectionmenu = array();
         $sectionmenu[course_get_url($course)->out(false)] = get_string('maincoursepage');
@@ -748,7 +772,19 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     }
 
     /**
-     * Output the html for a single section page .
+     * Output the html for a single section page.
+     *
+     * @deprecated since 4.0
+     *
+     * This is a deprecated method and it is mantain only for compatibilitiy with legacy course formats.
+     * Please, to render a single section page use:
+     *
+     * $format = course_get_format($course);
+     * // Set the section to display.
+     * $format->set_section_number($displaysection);
+     * $outputclass = $format->get_output_classname('course_format');
+     * $widget = new $outputclass($format);
+     * echo $this->render($widget);
      *
      * @param stdClass $course The course entry from DB
      * @param array $sections (argument not used)
@@ -758,27 +794,52 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * @param int $displaysection The section number in the course which is being displayed
      */
     public function print_single_section_page($course, $sections, $mods, $modnames, $modnamesused, $displaysection) {
-        $modinfo = get_fast_modinfo($course);
-        $course = course_get_format($course)->get_course();
+
+        debugging('Method print_single_section_page is deprecated, please use'.
+                'core_course\output\course_format and override render_course_format method instead', DEBUG_DEVELOPER);
+
+        // Some abstract methods are not needed anymore. We simulate them in case they are not present.
+        if (method_exists('start_section_list')) {
+            $startlist = $this->start_section_list();
+        } else {
+            $startlist = html_writer::start_tag('ul', ['class' => '']);
+        }
+        if (method_exists('end_section_list')) {
+            $endlist = $this->end_section_list();
+        } else {
+            $endlist = html_writer::end_tag('ul');
+        }
+
+        $format = course_get_format($course);
+
+        // Set the section to display.
+        $format->set_section_number($displaysection);
+
+        $modinfo = $format->get_modinfo();
+        $course = $format->get_course();
 
         // Can we view the section in question?
         if (!($sectioninfo = $modinfo->get_section_info($displaysection)) || !$sectioninfo->uservisible) {
             // This section doesn't exist or is not available for the user.
             // We actually already check this in course/view.php but just in case exit from this function as well.
-            print_error('unknowncoursesection', 'error', course_get_url($course),
-                format_string($course->fullname));
+            print_error(
+                'unknowncoursesection',
+                'error',
+                course_get_url($course),
+                format_string($course->fullname)
+            );
         }
 
         // Copy activity clipboard..
         echo $this->course_activity_clipboard($course, $displaysection);
         $thissection = $modinfo->get_section_info(0);
-        if ($thissection->summary or !empty($modinfo->sections[0]) or $this->page->user_is_editing()) {
-            echo $this->start_section_list();
+        if ($thissection->summary or !empty($modinfo->sections[0]) or $format->show_editor()) {
+            echo $startlist;
             echo $this->section_header($thissection, $course, true, $displaysection);
-            echo $this->courserenderer->course_section_cm_list($course, $thissection, $displaysection);
-            echo $this->courserenderer->course_section_add_cm_control($course, 0, $displaysection);
+            echo $this->course_section_cm_list($course, $thissection, $displaysection);
+            echo $this->course_section_add_cm_control($course, 0, $displaysection);
             echo $this->section_footer();
-            echo $this->end_section_list();
+            echo $endlist;
         }
 
         // Start single-section div
@@ -805,25 +866,28 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
         echo $sectiontitle;
 
         // Now the list of sections..
-        echo $this->start_section_list();
+        echo $startlist;
 
         echo $this->section_header($thissection, $course, true, $displaysection);
         // Show completion help icon.
         $completioninfo = new completion_info($course);
         echo $completioninfo->display_help_icon();
 
-        echo $this->courserenderer->course_section_cm_list($course, $thissection, $displaysection);
-        echo $this->courserenderer->course_section_add_cm_control($course, $displaysection, $displaysection);
+        echo $this->course_section_cm_list($course, $thissection, $displaysection);
+        echo $this->course_section_add_cm_control($course, $displaysection, $displaysection);
         echo $this->section_footer();
-        echo $this->end_section_list();
+        echo $endlist;
 
         // Display section bottom navigation.
         $sectionbottomnav = '';
         $sectionbottomnav .= html_writer::start_tag('div', array('class' => 'section-navigation mdl-bottom'));
         $sectionbottomnav .= html_writer::tag('span', $sectionnavlinks['previous'], array('class' => 'mdl-left'));
         $sectionbottomnav .= html_writer::tag('span', $sectionnavlinks['next'], array('class' => 'mdl-right'));
-        $sectionbottomnav .= html_writer::tag('div', $this->section_nav_selection($course, $sections, $displaysection),
-            array('class' => 'mdl-align'));
+        $sectionbottomnav .= html_writer::tag(
+            'div',
+            $this->section_nav_selection($course, $sections, $displaysection),
+            array('class' => 'mdl-align')
+        );
         $sectionbottomnav .= html_writer::end_tag('div');
         echo $sectionbottomnav;
 
@@ -834,6 +898,16 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
     /**
      * Output the html for a multiple section page
      *
+     * @deprecated since 4.0
+     *
+     * This is a deprecated method and it is mantain only for compatibilitiy with legacy course formats.
+     * Please, to render a single section page use:
+     *
+     * $format = course_get_format($course);
+     * $outputclass = $format->get_output_classname('course_format');
+     * $widget = new $outputclass($format);
+     * echo $this->render($widget);
+     *
      * @param stdClass $course The course entry from DB
      * @param array $sections (argument not used)
      * @param array $mods (argument not used)
@@ -841,29 +915,52 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
      * @param array $modnamesused (argument not used)
      */
     public function print_multiple_section_page($course, $sections, $mods, $modnames, $modnamesused) {
-        $modinfo = get_fast_modinfo($course);
-        $course = course_get_format($course)->get_course();
+
+        debugging('Method print_multiple_section_page is deprecated, please use'.
+                'render_course_format insteadand override render_course_format method instead', DEBUG_DEVELOPER);
+
+        // Some abstract methods are not needed anymore. We simulate them in case they are not present.
+        if (method_exists('start_section_list')) {
+            $startlist = $this->start_section_list();
+        } else {
+            $startlist = html_writer::start_tag('ul', ['class' => '']);
+        }
+        if (method_exists('end_section_list')) {
+            $endlist = $this->end_section_list();
+        } else {
+            $endlist = html_writer::end_tag('ul');
+        }
+        if (method_exists('page_title')) {
+            $pagetitle = $this->page_title();
+        } else {
+            $pagetitle = '';
+        }
+
+        $format = course_get_format($course);
+
+        $modinfo = $format->get_modinfo();
+        $course = $format->get_course();
 
         $context = context_course::instance($course->id);
         // Title with completion help icon.
         $completioninfo = new completion_info($course);
         echo $completioninfo->display_help_icon();
-        echo $this->output->heading($this->page_title(), 2, 'accesshide');
+        echo $this->output->heading($pagetitle, 2, 'accesshide');
 
         // Copy activity clipboard..
         echo $this->course_activity_clipboard($course, 0);
 
         // Now the list of sections..
-        echo $this->start_section_list();
+        echo $startlist;
         $numsections = course_get_format($course)->get_last_section_number();
 
         foreach ($modinfo->get_section_info_all() as $section => $thissection) {
             if ($section == 0) {
                 // 0-section is displayed a little different then the others
-                if ($thissection->summary or !empty($modinfo->sections[0]) or $this->page->user_is_editing()) {
+                if ($thissection->summary or !empty($modinfo->sections[0]) or $format->show_editor()) {
                     echo $this->section_header($thissection, $course, false, 0);
-                    echo $this->courserenderer->course_section_cm_list($course, $thissection, 0);
-                    echo $this->courserenderer->course_section_add_cm_control($course, 0, 0);
+                    echo $this->course_section_cm_list($course, $thissection, 0);
+                    echo $this->course_section_add_cm_control($course, 0, 0);
                     echo $this->section_footer();
                 }
                 continue;
@@ -876,26 +973,26 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
             // but there is some available info text which explains the reason & should display,
             // OR it is hidden but the course has a setting to display hidden sections as unavilable.
             $showsection = $thissection->uservisible ||
-                    ($thissection->visible && !$thissection->available && !empty($thissection->availableinfo)) ||
-                    (!$thissection->visible && !$course->hiddensections);
+                ($thissection->visible && !$thissection->available && !empty($thissection->availableinfo)) ||
+                (!$thissection->visible && !$course->hiddensections);
             if (!$showsection) {
                 continue;
             }
 
-            if (!$this->page->user_is_editing() && $course->coursedisplay == COURSE_DISPLAY_MULTIPAGE) {
+            if (!$format->show_editor() && $course->coursedisplay == COURSE_DISPLAY_MULTIPAGE) {
                 // Display section summary only.
                 echo $this->section_summary($thissection, $course, null);
             } else {
                 echo $this->section_header($thissection, $course, false, 0);
                 if ($thissection->uservisible) {
-                    echo $this->courserenderer->course_section_cm_list($course, $thissection, 0);
-                    echo $this->courserenderer->course_section_add_cm_control($course, $section, 0);
+                    echo $this->course_section_cm_list($course, $thissection, 0);
+                    echo $this->course_section_add_cm_control($course, $section, 0);
                 }
                 echo $this->section_footer();
             }
         }
 
-        if ($this->page->user_is_editing() and has_capability('moodle/course:update', $context)) {
+        if ($format->show_editor()) {
             // Print stealth sections if present.
             foreach ($modinfo->get_section_info_all() as $section => $thissection) {
                 if ($section <= $numsections or empty($modinfo->sections[$section])) {
@@ -903,111 +1000,71 @@ abstract class format_section_renderer_base extends plugin_renderer_base {
                     continue;
                 }
                 echo $this->stealth_section_header($section);
-                echo $this->courserenderer->course_section_cm_list($course, $thissection, 0);
+                echo $this->course_section_cm_list($course, $thissection, 0);
                 echo $this->stealth_section_footer();
             }
 
-            echo $this->end_section_list();
+            echo $endlist;
 
             echo $this->change_number_sections($course, 0);
         } else {
-            echo $this->end_section_list();
+            echo $endlist;
         }
-
     }
 
     /**
      * Returns controls in the bottom of the page to increase/decrease number of sections
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
      * @param stdClass $course
      * @param int|null $sectionreturn
-     * @return string
      */
     protected function change_number_sections($course, $sectionreturn = null) {
-        $coursecontext = context_course::instance($course->id);
-        if (!has_capability('moodle/course:update', $coursecontext)) {
-            return '';
-        }
+        debugging('Method change_number_sections is deprecated, please use'.
+                'core_course\output\course_format\addsection instead', DEBUG_DEVELOPER);
 
         $format = course_get_format($course);
-        $options = $format->get_format_options();
-        $maxsections = $format->get_max_sections();
-        $lastsection = $format->get_last_section_number();
-        $supportsnumsections = array_key_exists('numsections', $options);
-
-        if ($supportsnumsections) {
-            // Current course format has 'numsections' option, which is very confusing and we suggest course format
-            // developers to get rid of it (see MDL-57769 on how to do it).
-            // Display "Increase section" / "Decrease section" links.
-
-            echo html_writer::start_tag('div', array('id' => 'changenumsections', 'class' => 'mdl-right'));
-
-            // Increase number of sections.
-            if ($lastsection < $maxsections) {
-                $straddsection = get_string('increasesections', 'moodle');
-                $url = new moodle_url('/course/changenumsections.php',
-                    array('courseid' => $course->id,
-                          'increase' => true,
-                          'sesskey' => sesskey()));
-                $icon = $this->output->pix_icon('t/switch_plus', $straddsection);
-                echo html_writer::link($url, $icon.get_accesshide($straddsection), array('class' => 'increase-sections'));
-            }
-
-            if ($course->numsections > 0) {
-                // Reduce number of sections sections.
-                $strremovesection = get_string('reducesections', 'moodle');
-                $url = new moodle_url('/course/changenumsections.php',
-                    array('courseid' => $course->id,
-                          'increase' => false,
-                          'sesskey' => sesskey()));
-                $icon = $this->output->pix_icon('t/switch_minus', $strremovesection);
-                echo html_writer::link($url, $icon.get_accesshide($strremovesection), array('class' => 'reduce-sections'));
-            }
-
-            echo html_writer::end_tag('div');
-
-        } else if (course_get_format($course)->uses_sections()) {
-            if ($lastsection >= $maxsections) {
-                // Don't allow more sections if we already hit the limit.
-                return;
-            }
-            // Current course format does not have 'numsections' option but it has multiple sections suppport.
-            // Display the "Add section" link that will insert a section in the end.
-            // Note to course format developers: inserting sections in the other positions should check both
-            // capabilities 'moodle/course:update' and 'moodle/course:movesections'.
-            echo html_writer::start_tag('div', array('id' => 'changenumsections', 'class' => 'mdl-right'));
-            if (get_string_manager()->string_exists('addsections', 'format_'.$course->format)) {
-                $straddsections = get_string('addsections', 'format_'.$course->format);
-            } else {
-                $straddsections = get_string('addsections');
-            }
-            $url = new moodle_url('/course/changenumsections.php',
-                ['courseid' => $course->id, 'insertsection' => 0, 'sesskey' => sesskey()]);
-            if ($sectionreturn !== null) {
-                $url->param('sectionreturn', $sectionreturn);
-            }
-            $icon = $this->output->pix_icon('t/add', '');
-            $newsections = $maxsections - $lastsection;
-            echo html_writer::link($url, $icon . $straddsections,
-                array('class' => 'add-sections', 'data-add-sections' => $straddsections, 'data-new-sections' => $newsections));
-            echo html_writer::end_tag('div');
+        if ($sectionreturn) {
+            $format->set_section_number($sectionreturn);
         }
+        $outputclass = $format->get_output_classname('course_format\\addsection');
+        $widget = new $outputclass($format);
+        echo $this->render($widget);
     }
 
     /**
      * Generate html for a section summary text
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
      * @param stdClass $section The course_section entry from DB
      * @return string HTML to output.
      */
     protected function format_summary_text($section) {
-        $context = context_course::instance($section->course);
-        $summarytext = file_rewrite_pluginfile_urls($section->summary, 'pluginfile.php',
-            $context->id, 'course', 'section', $section->id);
+        debugging('Method format_summary_text is deprecated, please use'.
+                'core_course\output\section_format\summary::format_summary_text instead', DEBUG_DEVELOPER);
 
-        $options = new stdClass();
-        $options->noclean = true;
-        $options->overflowdiv = true;
-        return format_text($summarytext, $section->summaryformat, $options);
+        $format = course_get_format($section->course);
+        if (!($section instanceof section_info)) {
+            $modinfo = $format->get_modinfo();
+            $section = $modinfo->get_section_info($section->section);
+        }
+        $summaryclass = $format->get_output_classname('section_format\\summary');
+        $summary = new $summaryclass($format, $section);
+        return $summary->format_summary_text();
     }
 }
+
+/**
+ * Site topics renderer.
+ *
+ * Site course is not a real course format, but it requires a format renderer to use the output
+ * components.
+ *
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class format_site_renderer extends format_section_renderer_base {
+
+}
diff --git a/course/format/singleactivity/renderer.php b/course/format/singleactivity/renderer.php
index e9961a0c760..2b5ab56a6d6 100644
--- a/course/format/singleactivity/renderer.php
+++ b/course/format/singleactivity/renderer.php
@@ -23,6 +23,7 @@
  */
 
 defined('MOODLE_INTERNAL') || die();
+require_once($CFG->dirroot.'/course/format/renderer.php');
 
 /**
  * Basic renderer for singleactivity format.
@@ -31,7 +32,7 @@ defined('MOODLE_INTERNAL') || die();
  * @copyright  2013 Marina Glancy
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class format_singleactivity_renderer extends plugin_renderer_base {
+class format_singleactivity_renderer extends format_section_renderer_base {
 
     /**
      * Displays the activities list in cases when course view page is not
@@ -42,20 +43,28 @@ class format_singleactivity_renderer extends plugin_renderer_base {
      *     if true displays all other activities
      */
     public function display($course, $orphaned) {
-        $courserenderer = $this->page->get_renderer('core', 'course');
+
+        $format = course_get_format($course);
+        $modinfo = $format->get_modinfo();
+        $cmlistclass = $format->get_output_classname('section_format\\cmlist');
+
         $output = '';
-        $modinfo = get_fast_modinfo($course);
+
         if ($orphaned) {
             if (!empty($modinfo->sections[1])) {
                 $output .= $this->output->heading(get_string('orphaned', 'format_singleactivity'), 3, 'sectionname');
                 $output .= $this->output->box(get_string('orphanedwarning', 'format_singleactivity'));
-                $output .= $courserenderer->course_section_cm_list($course, 1, 1);
+
+                $section = $modinfo->get_section_info(1);
+                $output .= $this->render(new $cmlistclass($format, $section));
             }
         } else {
-            $output .= $courserenderer->course_section_cm_list($course, 0, 0);
+            $section = $modinfo->get_section_info(0);
+            $output .= $this->render(new $cmlistclass($format, $section));
+
             if (empty($modinfo->sections[0]) && course_get_format($course)->activity_has_subtypes()) {
                 // Course format was unable to automatically redirect to add module page.
-                $output .= $courserenderer->course_section_add_cm_control($course, 0, 0);
+                $output .= $this->course_section_add_cm_control($course, 0, 0);
             }
         }
         return $output;
diff --git a/course/format/topics/classes/output/section_format/controlmenu.php b/course/format/topics/classes/output/section_format/controlmenu.php
new file mode 100644
index 00000000000..2cb06516bcc
--- /dev/null
+++ b/course/format/topics/classes/output/section_format/controlmenu.php
@@ -0,0 +1,118 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Contains the default section controls output class.
+ *
+ * @package   format_topics
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace format_topics\output\section_format;
+
+use context_course;
+
+/**
+ * Base class to render a course section menu.
+ *
+ * @package   format_topics
+ * @copyright 2020 Ferran Recio <ferran@moodle.com>
+ * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class controlmenu extends \core_course\output\section_format\controlmenu {
+
+    /** @var course_format the course format class */
+    protected $format;
+
+    /** @var section_info the course section class */
+    protected $section;
+
+    /**
+     * Generate the edit control items of a section.
+     *
+     * This method must remain public until the final deprecation of section_edit_control_items.
+     *
+     * @return array of edit control items
+     */
+    public function section_control_items() {
+
+        $format = $this->format;
+        $section = $this->section;
+        $course = $format->get_course();
+        $sectionreturn = $format->get_section_number();
+
+        $coursecontext = context_course::instance($course->id);
+
+        if ($sectionreturn) {
+            $url = course_get_url($course, $section->section);
+        } else {
+            $url = course_get_url($course);
+        }
+        $url->param('sesskey', sesskey());
+
+        $controls = [];
+        if ($section->section && has_capability('moodle/course:setcurrentsection', $coursecontext)) {
+            if ($course->marker == $section->section) {  // Show the "light globe" on/off.
+                $url->param('marker', 0);
+                $highlightoff = get_string('highlightoff');
+                $controls['highlight'] = [
+                    'url' => $url,
+                    'icon' => 'i/marked',
+                    'name' => $highlightoff,
+                    'pixattr' => ['class' => ''],
+                    'attr' => [
+                        'class' => 'editing_highlight',
+                        'data-action' => 'removemarker'
+                    ],
+                ];
+            } else {
+                $url->param('marker', $section->section);
+                $highlight = get_string('highlight');
+                $controls['highlight'] = [
+                    'url' => $url,
+                    'icon' => 'i/marker',
+                    'name' => $highlight,
+                    'pixattr' => ['class' => ''],
+                    'attr' => [
+                        'class' => 'editing_highlight',
+                        'data-action' => 'setmarker'
+                    ],
+                ];
+            }
+        }
+
+        $parentcontrols = parent::section_control_items();
+
+        // If the edit key exists, we are going to insert our controls after it.
+        if (array_key_exists("edit", $parentcontrols)) {
+            $merged = [];
+            // We can't use splice because we are using associative arrays.
+            // Step through the array and merge the arrays.
+            foreach ($parentcontrols as $key => $action) {
+                $merged[$key] = $action;
+                if ($key == "edit") {
+                    // If we have come to the edit key, merge these controls here.
+                    $merged = array_merge($merged, $controls);
+                }
+            }
+
+            return $merged;
+        } else {
+            return array_merge($controls, $parentcontrols);
+        }
+    }
+}
diff --git a/course/format/topics/format.php b/course/format/topics/format.php
index 065798c90a4..4cd1c094090 100644
--- a/course/format/topics/format.php
+++ b/course/format/topics/format.php
@@ -37,9 +37,10 @@ if ($topic = optional_param('topic', 0, PARAM_INT)) {
 }
 // End backwards-compatible aliasing.
 
-$context = context_course::instance($course->id);
 // Retrieve course format option fields and add them to the $course object.
-$course = course_get_format($course)->get_course();
+$format = course_get_format($course);
+$course = $format->get_course();
+$context = context_course::instance($course->id);
 
 if (($marker >= 0) && has_capability('moodle/course:setcurrentsection', $context) && confirm_sesskey()) {
     $course->marker = $marker;
@@ -52,10 +53,11 @@ course_create_sections_if_missing($course, 0);
 $renderer = $PAGE->get_renderer('format_topics');
 
 if (!empty($displaysection)) {
-    $renderer->print_single_section_page($course, null, null, null, null, $displaysection);
-} else {
-    $renderer->print_multiple_section_page($course, null, null, null, null);
+    $format->set_section_number($displaysection);
 }
+$outputclass = $format->get_output_classname('course_format');
+$widget = new $outputclass($format);
+echo $renderer->render($widget);
 
 // Include course format js module.
 $PAGE->requires->js('/course/format/topics/format.js');
diff --git a/course/format/topics/lib.php b/course/format/topics/lib.php
index d11499410a0..23022419a44 100644
--- a/course/format/topics/lib.php
+++ b/course/format/topics/lib.php
@@ -35,7 +35,7 @@ use core\output\inplace_editable;
  * @copyright  2012 Marina Glancy
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class format_topics extends format_base {
+class format_topics extends core_course\course_format {
 
     /**
      * Returns true if this course format uses sections.
@@ -68,7 +68,7 @@ class format_topics extends format_base {
      * Returns the default section name for the topics course format.
      *
      * If the section number is 0, it will use the string with key = section0name from the course format's lang file.
-     * If the section number is not 0, the base implementation of format_base::get_default_section_name which uses
+     * If the section number is not 0, the base implementation of course_format::get_default_section_name which uses
      * the string with the key = 'sectionname' from the course format's lang file + the section number will be used.
      *
      * @param stdClass $section Section object from database or just field course_sections section
@@ -79,12 +79,21 @@ class format_topics extends format_base {
             // Return the general section.
             return get_string('section0name', 'format_topics');
         } else {
-            // Use format_base::get_default_section_name implementation which
+            // Use course_format::get_default_section_name implementation which
             // will display the section name in "Topic n" format.
             return parent::get_default_section_name($section);
         }
     }
 
+    /**
+     * Generate the title for this section page.
+     *
+     * @return string the page title
+     */
+    public function page_title(): string {
+        return get_string('topicoutline');
+    }
+
     /**
      * The URL to use for the specified course (with section).
      *
@@ -412,7 +421,15 @@ class format_topics extends format_base {
         // For show/hide actions call the parent method and return the new content for .section_availability element.
         $rv = parent::section_action($section, $action, $sr);
         $renderer = $PAGE->get_renderer('format_topics');
-        $rv['section_availability'] = $renderer->section_availability($this->get_section($section));
+
+        if (!($section instanceof section_info)) {
+            $modinfo = $this->get_modinfo();
+            $section = $modinfo->get_section_info($section->section);
+        }
+        $elementclass = $this->get_output_classname('section_format\\availability');
+        $availability = new $elementclass($this, $section);
+
+        $rv['section_availability'] = $renderer->render($availability);
         return $rv;
     }
 
diff --git a/course/format/topics/renderer.php b/course/format/topics/renderer.php
index 8b735c393fb..4a5fddb846b 100644
--- a/course/format/topics/renderer.php
+++ b/course/format/topics/renderer.php
@@ -49,33 +49,6 @@ class format_topics_renderer extends format_section_renderer_base {
         $page->set_other_editing_capability('moodle/course:setcurrentsection');
     }
 
-    /**
-     * Generate the starting container html for a list of sections.
-     *
-     * @return string HTML to output.
-     */
-    protected function start_section_list() {
-        return html_writer::start_tag('ul', ['class' => 'topics']);
-    }
-
-    /**
-     * Generate the closing container html for a list of sections.
-     *
-     * @return string HTML to output.
-     */
-    protected function end_section_list() {
-        return html_writer::end_tag('ul');
-    }
-
-    /**
-     * Generate the title for this section page.
-     *
-     * @return string the page title
-     */
-    protected function page_title() {
-        return get_string('topicoutline');
-    }
-
     /**
      * Generate the section title, wraps it in a link to the section page if page is to be displayed on a separate page.
      *
@@ -98,77 +71,4 @@ class format_topics_renderer extends format_section_renderer_base {
         return $this->render(course_get_format($course)->inplace_editable_render_section_name($section, false));
     }
 
-    /**
-     * Generate the edit control items of a section.
-     *
-     * @param int|stdClass $course The course entry from DB
-     * @param section_info|stdClass $section The course_section entry from DB
-     * @param bool $onsectionpage true if being printed on a section page
-     * @return array of edit control items
-     */
-    protected function section_edit_control_items($course, $section, $onsectionpage = false) {
-        if (!$this->page->user_is_editing()) {
-            return [];
-        }
-
-        $coursecontext = context_course::instance($course->id);
-
-        if ($onsectionpage) {
-            $url = course_get_url($course, $section->section);
-        } else {
-            $url = course_get_url($course);
-        }
-        $url->param('sesskey', sesskey());
-
-        $controls = [];
-        if ($section->section && has_capability('moodle/course:setcurrentsection', $coursecontext)) {
-            if ($course->marker == $section->section) {  // Show the "light globe" on/off.
-                $url->param('marker', 0);
-                $highlightoff = get_string('highlightoff');
-                $controls['highlight'] = [
-                    'url' => $url,
-                    'icon' => 'i/marked',
-                    'name' => $highlightoff,
-                    'pixattr' => ['class' => ''],
-                    'attr' => [
-                        'class' => 'editing_highlight',
-                        'data-action' => 'removemarker'
-                    ],
-                ];
-            } else {
-                $url->param('marker', $section->section);
-                $highlight = get_string('highlight');
-                $controls['highlight'] = [
-                    'url' => $url,
-                    'icon' => 'i/marker',
-                    'name' => $highlight,
-                    'pixattr' => ['class' => ''],
-                    'attr' => [
-                        'class' => 'editing_highlight',
-                        'data-action' => 'setmarker'
-                    ],
-                ];
-            }
-        }
-
-        $parentcontrols = parent::section_edit_control_items($course, $section, $onsectionpage);
-
-        // If the edit key exists, we are going to insert our controls after it.
-        if (array_key_exists("edit", $parentcontrols)) {
-            $merged = [];
-            // We can't use splice because we are using associative arrays.
-            // Step through the array and merge the arrays.
-            foreach ($parentcontrols as $key => $action) {
-                $merged[$key] = $action;
-                if ($key == "edit") {
-                    // If we have come to the edit key, merge these controls here.
-                    $merged = array_merge($merged, $controls);
-                }
-            }
-
-            return $merged;
-        } else {
-            return array_merge($controls, $parentcontrols);
-        }
-    }
 }
diff --git a/course/format/weeks/format.php b/course/format/weeks/format.php
index da82d080a72..d32aafaaf62 100644
--- a/course/format/weeks/format.php
+++ b/course/format/weeks/format.php
@@ -37,16 +37,19 @@ if ($week = optional_param('week', 0, PARAM_INT)) {
 }
 // End backwards-compatible aliasing..
 
+$format = course_get_format($course);
+
 // Make sure section 0 is created.
-$course = course_get_format($course)->get_course();
-course_create_sections_if_missing($course, 0);
+course_create_sections_if_missing($format->get_course(), 0);
 
 $renderer = $PAGE->get_renderer('format_weeks');
 
 if (!empty($displaysection)) {
-    $renderer->print_single_section_page($course, null, null, null, null, $displaysection);
-} else {
-    $renderer->print_multiple_section_page($course, null, null, null, null);
+    $format->set_section_number($displaysection);
 }
 
+$outputclass = $format->get_output_classname('course_format');
+$output = new $outputclass($format);
+echo $renderer->render($output);
+
 $PAGE->requires->js('/course/format/weeks/format.js');
diff --git a/course/format/weeks/lib.php b/course/format/weeks/lib.php
index 30fab80f671..00e4aab55cd 100644
--- a/course/format/weeks/lib.php
+++ b/course/format/weeks/lib.php
@@ -45,6 +45,14 @@ class format_weeks extends core_course\course_format {
         return true;
     }
 
+    /**
+     * Generate the title for this section page
+     * @return string the page title
+     */
+    public function page_title(): string {
+        return get_string('weeklyoutline');
+    }
+
     /**
      * Returns the display name of the given section that the course prefers.
      *
@@ -505,7 +513,16 @@ class format_weeks extends core_course\course_format {
         // Call the parent method and return the new content for .section_availability element.
         $rv = parent::section_action($section, $action, $sr);
         $renderer = $PAGE->get_renderer('format_weeks');
-        $rv['section_availability'] = $renderer->section_availability($this->get_section($section));
+
+        if (!($section instanceof section_info)) {
+            $modinfo = $this->get_modinfo();
+            $section = $modinfo->get_section_info($section->section);
+        }
+        $elementclass = $this->get_output_classname('section_format\\availability');
+        $availability = new $elementclass($this, $section);
+
+        $rv['section_availability'] = $renderer->render($availability);
+
         return $rv;
     }
 
diff --git a/course/format/weeks/renderer.php b/course/format/weeks/renderer.php
index af45ae3c991..7f29ee1e090 100644
--- a/course/format/weeks/renderer.php
+++ b/course/format/weeks/renderer.php
@@ -28,6 +28,7 @@ defined('MOODLE_INTERNAL') || die();
 require_once($CFG->dirroot.'/course/format/renderer.php');
 require_once($CFG->dirroot.'/course/format/weeks/lib.php');
 
+use core_course\output\section_format\availability;
 
 /**
  * Basic renderer for weeks format.
@@ -36,29 +37,6 @@ require_once($CFG->dirroot.'/course/format/weeks/lib.php');
  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 class format_weeks_renderer extends format_section_renderer_base {
-    /**
-     * Generate the starting container html for a list of sections
-     * @return string HTML to output.
-     */
-    protected function start_section_list() {
-        return html_writer::start_tag('ul', array('class' => 'weeks'));
-    }
-
-    /**
-     * Generate the closing container html for a list of sections
-     * @return string HTML to output.
-     */
-    protected function end_section_list() {
-        return html_writer::end_tag('ul');
-    }
-
-    /**
-     * Generate the title for this section page
-     * @return string the page title
-     */
-    protected function page_title() {
-        return get_string('weeklyoutline');
-    }
 
     /**
      * Generate the section title, wraps it in a link to the section page if page is to be displayed on a separate page
diff --git a/course/lib.php b/course/lib.php
index 4fe1c9a67c9..547d2d3e956 100644
--- a/course/lib.php
+++ b/course/lib.php
@@ -3420,12 +3420,15 @@ function mod_duplicate_activity($course, $cm, $sr = null) {
 
     $resp = new stdClass();
     if ($newcm) {
-        $courserenderer = $PAGE->get_renderer('core', 'course');
-        $completioninfo = new completion_info($course);
-        $modulehtml = $courserenderer->course_section_cm($course, $completioninfo,
-                $newcm, null, array());
 
-        $resp->fullcontent = $courserenderer->course_section_cm_list_item($course, $completioninfo, $newcm, $sr);
+        $format = course_get_format($course);
+        $renderer = $format->get_renderer($PAGE);
+        $modinfo = $format->get_modinfo();
+        $section = $modinfo->get_section_info($newcm->sectionnum);
+
+        // Get the new element html content.
+        $resp->fullcontent = $renderer->course_section_updated_cm_item($format, $section, $newcm);
+
         $resp->cmid = $newcm->id;
     } else {
         // Trigger a redirect.
diff --git a/course/renderer.php b/course/renderer.php
index a015676ecfd..57af2281c4a 100644
--- a/course/renderer.php
+++ b/course/renderer.php
@@ -815,6 +815,8 @@ class core_course_renderer extends plugin_renderer_base {
     /**
      * Renders HTML to display one course module for display within a section.
      *
+     * @deprecated since 4.0 - use core_course output components or course_format::course_section_updated_cm_item instead.
+     *
      * This function calls:
      * {@link core_course_renderer::course_section_cm()}
      *
@@ -825,7 +827,11 @@ class core_course_renderer extends plugin_renderer_base {
      * @param array $displayoptions
      * @return String
      */
-    public function course_section_cm_list_item($course, &$completioninfo, cm_info $mod, $sectionreturn, $displayoptions = array()) {
+    public function course_section_cm_list_item($course, &$completioninfo, cm_info $mod, $sectionreturn, $displayoptions = []) {
+
+        debugging('course_section_cm_list_item is deprecated. Use course_format::course_section_updated_cm_item instead',
+                DEBUG_DEVELOPER);
+
         $output = '';
         if ($modulehtml = $this->course_section_cm($course, $completioninfo, $mod, $sectionreturn, $displayoptions)) {
             $modclasses = 'activity ' . $mod->modname . ' modtype_' . $mod->modname . ' ' . $mod->extraclasses;
@@ -840,6 +846,8 @@ class core_course_renderer extends plugin_renderer_base {
      * This includes link, content, availability, completion info and additional information
      * that module type wants to display (i.e. number of unread forum posts)
      *
+     * @deprecated since 4.0 - use core_course output components instead.
+     *
      * This function calls:
      * {@link core_course_renderer::course_section_cm_name()}
      * {@link core_course_renderer::course_section_cm_text()}
@@ -855,98 +863,27 @@ class core_course_renderer extends plugin_renderer_base {
      * @param array $displayoptions
      * @return string
      */
-    public function course_section_cm($course, &$completioninfo, cm_info $mod, $sectionreturn, $displayoptions = array()) {
-        $output = '';
-        // We return empty string (because course module will not be displayed at all)
-        // if:
-        // 1) The activity is not visible to users
-        // and
-        // 2) The 'availableinfo' is empty, i.e. the activity was
-        //     hidden in a way that leaves no info, such as using the
-        //     eye icon.
+    public function course_section_cm($course, &$completioninfo, cm_info $mod, $sectionreturn, $displayoptions = []) {
+
+        debugging('course_section_cm is deprecated. Use core_course\output\cm_format output classes instead.', DEBUG_DEVELOPER);
+
         if (!$mod->is_visible_on_course_page()) {
-            return $output;
+            return '';
         }
 
-        $indentclasses = 'mod-indent';
-        if (!empty($mod->indent)) {
-            $indentclasses .= ' mod-indent-'.$mod->indent;
-            if ($mod->indent > 15) {
-                $indentclasses .= ' mod-indent-huge';
-            }
+        $format = course_get_format($course);
+        $modinfo = $format->get_modinfo();
+        // Output renderers works only with real section_info objects.
+        if ($sectionreturn) {
+            $format->set_section_number($sectionreturn);
         }
+        $section = $modinfo->get_section_info($format->get_section_number());
 
-        $output .= html_writer::start_tag('div');
-
-        if ($this->page->user_is_editing()) {
-            $output .= course_get_cm_move($mod, $sectionreturn);
-        }
-
-        $output .= html_writer::start_tag('div', array('class' => 'mod-indent-outer w-100'));
-
-        // This div is used to indent the content.
-        $output .= html_writer::div('', $indentclasses);
-
-        // Start a wrapper for the actual content to keep the indentation consistent
-        $output .= html_writer::start_tag('div');
-
-        // Display the link to the module (or do nothing if module has no url)
-        $cmname = $this->course_section_cm_name($mod, $displayoptions);
-
-        if (!empty($cmname)) {
-            // Start the div for the activity title, excluding the edit icons.
-            $output .= html_writer::start_tag('div', array('class' => 'activityinstance'));
-            $output .= $cmname;
-
-
-            // Module can put text after the link (e.g. forum unread)
-            $output .= $mod->afterlink;
-
-            // Closing the tag which contains everything but edit icons. Content part of the module should not be part of this.
-            $output .= html_writer::end_tag('div'); // .activityinstance
-        }
-
-        // If there is content but NO link (eg label), then display the
-        // content here (BEFORE any icons). In this case cons must be
-        // displayed after the content so that it makes more sense visually
-        // and for accessibility reasons, e.g. if you have a one-line label
-        // it should work similarly (at least in terms of ordering) to an
-        // activity.
-        $contentpart = $this->course_section_cm_text($mod, $displayoptions);
-        $url = $mod->url;
-        if (empty($url)) {
-            $output .= $contentpart;
-        }
-
-        $modicons = '';
-        if ($this->page->user_is_editing()) {
-            $editactions = course_get_cm_edit_actions($mod, $mod->indent, $sectionreturn);
-            $modicons .= ' '. $this->course_section_cm_edit_actions($editactions, $mod, $displayoptions);
-            $modicons .= $mod->afterediticons;
-        }
-
-        $modicons .= $this->course_section_cm_completion($course, $completioninfo, $mod, $displayoptions);
-
-        if (!empty($modicons)) {
-            $output .= html_writer::div($modicons, 'actions');
-        }
-
-        // Show availability info (if module is not available).
-        $output .= $this->course_section_cm_availability($mod, $displayoptions);
-
-        // If there is content AND a link, then display the content here
-        // (AFTER any icons). Otherwise it was displayed before
-        if (!empty($url)) {
-            $output .= $contentpart;
-        }
-
-        $output .= html_writer::end_tag('div'); // $indentclasses
-
-        // End of indentation div.
-        $output .= html_writer::end_tag('div');
-
-        $output .= html_writer::end_tag('div');
-        return $output;
+        $cmclass = $format->get_output_classname('cm_format');
+        $cm = new $cmclass($format, $section, $completioninfo, $mod, $displayoptions);
+        // The course outputs works with format renderers, not with course renderers.
+        $renderer = $format->get_renderer($this->page);
+        return $renderer->render($cm);
     }
 
     /**
@@ -979,7 +916,9 @@ class core_course_renderer extends plugin_renderer_base {
 
     /**
      * Renders HTML to display a list of course modules in a course section
-     * Also displays "move here" controls in Javascript-disabled mode
+     * Also displays "move here" controls in Javascript-disabled mode.
+     *
+     * @deprecated since 4.0 - use core_course output components instead.
      *
      * This function calls {@link core_course_renderer::course_section_cm()}
      *
@@ -989,11 +928,17 @@ class core_course_renderer extends plugin_renderer_base {
      * @param int $displayoptions
      * @return void
      */
-    public function course_section_cm_list($course, $section, $sectionreturn = null, $displayoptions = array()) {
+    public function course_section_cm_list($course, $section, $sectionreturn = null, $displayoptions = []) {
         global $USER;
 
+        debugging('course_section_cm_list is deprecated. Use core_course\\output\\section_format\\cmlist '.
+                'classes instead.', DEBUG_DEVELOPER);
+
         $output = '';
-        $modinfo = get_fast_modinfo($course);
+
+        $format = course_get_format($course);
+        $modinfo = $format->get_modinfo();
+
         if (is_object($section)) {
             $section = $modinfo->get_section_info($section->section);
         } else {
@@ -1002,13 +947,14 @@ class core_course_renderer extends plugin_renderer_base {
         $completioninfo = new completion_info($course);
 
         // check if we are currently in the process of moving a module with JavaScript disabled
-        $ismoving = $this->page->user_is_editing() && ismoving($course->id);
+        $ismoving = $format->show_editor() && ismoving($course->id);
+
         if ($ismoving) {
             $strmovefull = strip_tags(get_string("movefull", "", "'$USER->activitycopyname'"));
         }
 
         // Get the list of modules visible to user (excluding the module being moved if there is one)
-        $moduleshtml = array();
+        $moduleshtml = [];
         if (!empty($modinfo->sections[$section->section])) {
             foreach ($modinfo->sections[$section->section] as $modnumber) {
                 $mod = $modinfo->cms[$modnumber];
@@ -1031,8 +977,8 @@ class core_course_renderer extends plugin_renderer_base {
                 if ($ismoving) {
                     $movingurl = new moodle_url('/course/mod.php', array('moveto' => $modnumber, 'sesskey' => sesskey()));
                     $sectionoutput .= html_writer::tag('li',
-                            html_writer::link($movingurl, '', array('title' => $strmovefull, 'class' => 'movehere')),
-                            array('class' => 'movehere'));
+                        html_writer::link($movingurl, '', array('title' => $strmovefull, 'class' => 'movehere')),
+                        array('class' => 'movehere'));
                 }
 
                 $sectionoutput .= $modulehtml;
@@ -1041,8 +987,8 @@ class core_course_renderer extends plugin_renderer_base {
             if ($ismoving) {
                 $movingurl = new moodle_url('/course/mod.php', array('movetosection' => $section->id, 'sesskey' => sesskey()));
                 $sectionoutput .= html_writer::tag('li',
-                        html_writer::link($movingurl, '', array('title' => $strmovefull, 'class' => 'movehere')),
-                        array('class' => 'movehere'));
+                    html_writer::link($movingurl, '', array('title' => $strmovefull, 'class' => 'movehere')),
+                    array('class' => 'movehere'));
             }
         }
 
@@ -2256,53 +2202,17 @@ class core_course_renderer extends plugin_renderer_base {
 
         $modinfo = get_fast_modinfo($SITE);
         $section = $modinfo->get_section_info(1);
+
+
         if (($section && (!empty($modinfo->sections[1]) or !empty($section->summary))) or $editing) {
-            $output .= $this->box_start('generalbox sitetopic');
 
-            // If currently moving a file then show the current clipboard.
-            if (ismoving($SITE->id)) {
-                $stractivityclipboard = strip_tags(get_string('activityclipboard', '', $USER->activitycopyname));
-                $output .= '<p><font size="2">';
-                $cancelcopyurl = new moodle_url('/course/mod.php', ['cancelcopy' => 'true', 'sesskey' => sesskey()]);
-                $output .= "$stractivityclipboard&nbsp;&nbsp;(" . html_writer::link($cancelcopyurl, get_string('cancel')) .')';
-                $output .= '</font></p>';
-            }
+            $format = course_get_format($SITE);
+            $frontpageclass = $format->get_output_classname('course_format\\frontpagesection');
+            $frontpagesection = new $frontpageclass($format, $section);
 
-            $context = context_course::instance(SITEID);
-
-            // If the section name is set we show it.
-            if (trim($section->name) !== '') {
-                $output .= $this->heading(
-                    format_string($section->name, true, array('context' => $context)),
-                    2,
-                    'sectionname'
-                );
-            }
-
-            $summarytext = file_rewrite_pluginfile_urls($section->summary,
-                'pluginfile.php',
-                $context->id,
-                'course',
-                'section',
-                $section->id);
-            $summaryformatoptions = new stdClass();
-            $summaryformatoptions->noclean = true;
-            $summaryformatoptions->overflowdiv = true;
-
-            $output .= format_text($summarytext, $section->summaryformat, $summaryformatoptions);
-
-            if ($editing && has_capability('moodle/course:update', $context)) {
-                $streditsummary = get_string('editsummary');
-                $editsectionurl = new moodle_url('/course/editsection.php', ['id' => $section->id]);
-                $attributes = ['title' => $streditsummary, 'aria-label' => $streditsummary];
-                $output .= html_writer::link($editsectionurl, $this->pix_icon('t/edit', ''), $attributes) .
-                    "<br /><br />";
-            }
-
-            $output .= $this->course_section_cm_list($SITE, $section);
-
-            $output .= $this->course_section_add_cm_control($SITE, $section->section);
-            $output .= $this->box_end();
+            // The course outputs works with format renderers, not with course renderers.
+            $renderer = $format->get_renderer($this->page);
+            $output .= $renderer->render($frontpagesection);
         }
 
         return $output;
diff --git a/course/templates/local/cm_format.mustache b/course/templates/local/cm_format.mustache
new file mode 100644
index 00000000000..0e905d36d55
--- /dev/null
+++ b/course/templates/local/cm_format.mustache
@@ -0,0 +1,69 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/cm_format
+
+    Displays a course module instance inside a course section.
+
+    Example context (json):
+    {
+        "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Activity example</span></a>",
+        "hasname": "true",
+        "moveicon": "<i>[Move]</i>",
+        "indent": 2,
+        "afterlink": "<span class=\"badge badge-primary\">30 unread messages</span>",
+        "hasextras": true,
+        "extras": ["<span class=\"badge badge-secondary\">[extras]</span>"],
+        "completion": "<span class=\"badge badge-success\">Completed!</span>",
+        "availability": "<div><span class=\"badge badge-info\">Restricted</span> Available from <strong>3 Dec 2029</strong></div>"
+
+    }
+}}
+<div>
+    <div class="mod-indent-outer w-100">
+        {{#moveicon}} {{{moveicon}}} {{/moveicon}}
+        {{! This div is used to indent the content. }}
+        <div class="mod-indent {{#indent}}mod-indent-{{indent}}{{/indent}} {{#hugeindent}}mod-indent-huge{{/hugeindent}}"></div>
+        {{! Start a wrapper for the actual content to keep the indentation consistent. }}
+        <div>
+            {{! Display the link to the module (or do nothing if module has no url). }}
+            {{#hasname}}
+            <div class="activityinstance">
+                {{{cmname}}} {{{afterlink}}}
+            </div>
+            {{/hasname}}
+            {{! If there is content but NO link (eg label), then display the
+            content here (BEFORE any icons). In this case cons must be
+            displayed after the content so that it makes more sense visually
+            and for accessibility reasons, e.g. if you have a one-line label
+            it should work similarly (at least in terms of ordering) to an
+            activity. }}
+            {{^hasurl}} {{{altcontent}}} {{/hasurl}}
+
+            {{#hasextras}}
+            <div class="actions">
+                {{#extras}} {{{.}}} {{/extras}}
+                {{{completion}}}
+            </div>
+            {{/hasextras}}
+
+            {{{availability}}}
+
+            {{#hasurl}} {{{altcontent}}} {{/hasurl}}
+        </div>
+    </div>
+</div>
diff --git a/course/templates/local/course_format.mustache b/course/templates/local/course_format.mustache
new file mode 100644
index 00000000000..cb1d061a70f
--- /dev/null
+++ b/course/templates/local/course_format.mustache
@@ -0,0 +1,181 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/course_format
+
+    Displays the complete course format.
+
+    Example context (json):
+    {
+        "initialsection": {
+                "num": 0,
+                "id": 34,
+                "cmlist": {
+                    "cms": [
+                        {
+                            "cmitem": {
+                                "cmformat": {
+                                    "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Forum example</span></a>",
+                                    "hasname": "true"
+                                },
+                                "id": 3,
+                                "module": "forum",
+                                "extraclasses": "newmessages"
+                            }
+                        }
+                    ],
+                    "hascms": true
+                },
+                "iscurrent": true,
+                "summary": {
+                    "summarytext": "Summary text!"
+                }
+            },
+        "sections": [
+            {
+                "num": 1,
+                "id": 35,
+                "header": {
+                    "name": "Section title",
+                    "url": "#"
+                },
+                "cmlist": {
+                    "cms": [
+                        {
+                            "cmitem": {
+                                "cmformat": {
+                                    "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Another forum</span></a>",
+                                    "hasname": "true"
+                                },
+                                "id": 3,
+                                "module": "forum",
+                                "extraclasses": "newmessages"
+                            }
+                        }
+                    ],
+                    "hascms": true
+                },
+                "iscurrent": true,
+                "summary": {
+                    "summarytext": "Summary text!"
+                }
+            },
+            {
+                "num": 4,
+                "id": 36,
+                "header": {
+                    "name": "Section 2 title",
+                    "url": "#"
+                },
+                "cmlist": {
+                    "cms": [
+                        {
+                            "cmitem": {
+                                "cmformat": {
+                                    "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Forum example</span></a>",
+                                    "hasname": "true"
+                                },
+                                "id": 5,
+                                "module": "forum",
+                                "extraclasses": "newmessages"
+                            }
+                        }
+                    ],
+                    "hascms": true
+                },
+                "iscurrent": true,
+                "summary": {
+                    "summarytext": "Summary text!"
+                }
+            }
+        ],
+        "format": "topics",
+        "title": "Course title example",
+            "hasnavigation": true,
+            "sectionnavigation": {
+            "hasprevious": true,
+            "previousurl": "#",
+            "larrow": "&#x25C4;",
+            "previousname": "Section 3",
+            "hasnext": true,
+            "rarrow": "&#x25BA;",
+            "nexturl": "#",
+            "nextname": "Section 5"
+        },
+        "sectionselector": {
+            "hasprevious": true,
+            "previousurl": "#",
+            "larrow": "&#x25C4;",
+            "previousname": "Section 3",
+            "hasnext": true,
+            "rarrow": "&#x25BA;",
+            "nexturl": "#",
+            "nextname": "Section 5",
+            "selector": "<select><option>Section 4</option></select>"
+        },
+        "singlesection": {
+            "num": 1,
+            "id": 35,
+            "header": {
+                "name": "Single Section Example",
+                "url": "#"
+            },
+            "cmlist": {
+                "cms": [
+                    {
+                        "cmitem": {
+                            "cmformat": {
+                                "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Assign example</span></a>",
+                                "hasname": "true"
+                            },
+                            "id": 4,
+                            "module": "assign",
+                            "extraclasses": ""
+                        }
+                    }
+                ],
+                "hascms": true
+            },
+            "iscurrent": true,
+            "summary": {
+                "summarytext": "Summary text!"
+            }
+        }
+    }
+}}
+<h2 class="accesshide">{{{title}}}</h2>
+{{{completionhelp}}}
+<ul class="{{format}}">
+    {{#initialsection}}
+        {{> core_course/local/section_format }}
+    {{/initialsection}}
+    {{#sections}}
+        {{> core_course/local/section_format }}
+    {{/sections}}
+</ul>
+{{#hasnavigation}}
+<div class="single-section">
+    {{#sectionnavigation}} {{> core_course/local/course_format/sectionnavigation }} {{/sectionnavigation}}
+    <ul class="{{format}}">
+    {{#singlesection}}
+        {{> core_course/local/section_format }}
+    {{/singlesection}}
+    </ul>
+    {{#sectionselector}} {{> core_course/local/course_format/sectionselector }} {{/sectionselector}}
+</div>
+{{/hasnavigation}}
+{{#numsections}} {{> core_course/local/course_format/addsection}} {{/numsections}}
diff --git a/course/templates/local/course_format/addsection.mustache b/course/templates/local/course_format/addsection.mustache
new file mode 100644
index 00000000000..9de9ad0891a
--- /dev/null
+++ b/course/templates/local/course_format/addsection.mustache
@@ -0,0 +1,56 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/course_format/addsection
+
+    Displays the add section button inside a course.
+
+    Example context (json):
+    {
+        "showaddsection": true,
+        "increase": {
+            "url": "#"
+        },
+        "decrease": {
+            "url": "#"
+        },
+        "addsections": {
+            "url": "#",
+            "title": "Add section",
+            "newsection": 3
+        }
+    }
+}}
+{{#showaddsection}}
+<div id="changenumsections" class="mdl-right">
+    {{#increase}}
+    <a href="{{{url}}}" class="increase-sections">
+        {{#pix}}t/switch_plus, moodle, {{#str}} increasesections, moodle {{/str}}{{/pix}}
+    </a>
+    {{/increase}}
+    {{#decrease}}
+    <a href="{{{url}}}" class="reduce-sections">
+        {{#pix}}t/switch_minus, moodle, {{#str}} reducesections, moodle {{/str}}{{/pix}}
+    </a>
+    {{/decrease}}
+    {{#addsections}}
+    <a href="{{{url}}}" class="add-sections" data-add-sections="{{title}}" data-new-sections="{{newsection}}">
+        {{#pix}} t/add, moodle {{/pix}} {{title}}
+    </a>
+    {{/addsections}}
+</div>
+{{/showaddsection}}
diff --git a/course/templates/local/course_format/frontpagesection.mustache b/course/templates/local/course_format/frontpagesection.mustache
new file mode 100644
index 00000000000..0b38363065c
--- /dev/null
+++ b/course/templates/local/course_format/frontpagesection.mustache
@@ -0,0 +1,46 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/course_format/frontpagesection
+
+    Displays the frontpage section 1 (site home).
+
+    Example context (json):
+    {
+        "sections": [
+            "<li>This is the section content</li>"
+        ],
+        "showsettings": true,
+        "settingsurl": "#"
+    }
+}}
+<div class="course-content">
+    {{#showsettings}}
+    <div class="mb-2">
+        <a href="{{{settingsurl}}}" title="{{#str}} editsummary {{/str}}" aria-label="{{#str}} editsummary {{/str}}">
+            {{#pix}} t/edit, moodle {{/pix}}
+        </a>
+    </div>
+    {{/showsettings}}
+    <div class="sitetopic">
+        <ul class="topics frontpage">
+            {{#sections}}
+                {{> core_course/local/section_format }}
+            {{/sections}}
+        </ul>
+    </div>
+</div>
diff --git a/course/templates/local/course_format/sectionnavigation.mustache b/course/templates/local/course_format/sectionnavigation.mustache
new file mode 100644
index 00000000000..d1fc2c5905c
--- /dev/null
+++ b/course/templates/local/course_format/sectionnavigation.mustache
@@ -0,0 +1,49 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/course_format/sectionnavigation
+
+    Displays the course section navigation.
+
+    Example context (json):
+    {
+        "hasprevious": true,
+        "previousurl": "#",
+        "larrow": "&#x25C4;",
+        "previousname": "Section 3",
+        "hasnext": true,
+        "rarrow": "&#x25BA;",
+        "nexturl": "#",
+        "nextname": "Section 5"
+    }
+}}
+<div class="section-navigation navigationtitle d-flex justify-content-between">
+    <div class="prevsection">
+        {{#hasprevious}}
+        <a href="{{{previousurl}}}" class="{{#previoushidden}} dimmed_text {{/previoushidden}}">
+            <span class="larrow">{{{larrow}}}</span>{{{previousname}}}
+        </a>
+        {{/hasprevious}}
+    </div>
+    <div class="nextsection">
+        {{#hasnext}}
+        <a href="{{{nexturl}}}" class="{{#nexthidden}} dimmed_text {{/nexthidden}}">
+            <span class="rarrow">{{{rarrow}}}</span>{{{nextname}}}
+        </a>
+        {{/hasnext}}
+    </div>
+</div>
diff --git a/course/templates/local/course_format/sectionselector.mustache b/course/templates/local/course_format/sectionselector.mustache
new file mode 100644
index 00000000000..630fa749ccc
--- /dev/null
+++ b/course/templates/local/course_format/sectionselector.mustache
@@ -0,0 +1,53 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/course_format/sectionselector
+
+    Displays the course section navigation.
+
+    Example context (json):
+    {
+        "hasprevious": true,
+        "previousurl": "#",
+        "larrow": "&#x25C4;",
+        "previousname": "Section 3",
+        "hasnext": true,
+        "rarrow": "&#x25BA;",
+        "nexturl": "#",
+        "nextname": "Section 5",
+        "selector": "<select><option>Section 4</option></select>"
+    }
+}}
+<div class="section-navigation mdl-bottom d-flex justify-content-between">
+    <div class="prevsection">
+        {{#hasprevious}}
+        <a href="{{{previousurl}}}" class="{{#previoushidden}} dimmed_text {{/previoushidden}}">
+            <span class="larrow">{{{larrow}}}</span>{{{previousname}}}
+        </a>
+        {{/hasprevious}}
+    </div>
+    <div>
+        {{{selector}}}
+    </div>
+    <div class="nextsection">
+        {{#hasnext}}
+        <a href="{{{nexturl}}}" class="{{#nexthidden}} dimmed_text {{/nexthidden}}">
+            <span class="rarrow">{{{rarrow}}}</span>{{{nextname}}}
+        </a>
+        {{/hasnext}}
+    </div>
+</div>
diff --git a/course/templates/local/section_format.mustache b/course/templates/local/section_format.mustache
new file mode 100644
index 00000000000..ccb9f901454
--- /dev/null
+++ b/course/templates/local/section_format.mustache
@@ -0,0 +1,107 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format
+
+    Displays a course section.
+
+    Example context (json):
+    {
+        "num": 3,
+        "id": 35,
+        "controlmenu": "[tools menu]",
+        "header": {
+            "name": "Section title",
+            "url": "#",
+            "ishidden": true
+        },
+        "cmlist": {
+            "cms": [
+                {
+                    "cmitem": {
+                        "cmformat": {
+                            "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Forum example</span></a>",
+                            "hasname": "true"
+                        },
+                        "id": 3,
+                        "module": "forum",
+                        "extraclasses": "newmessages"
+                    }
+                },
+                {
+                    "cmitem": {
+                        "cmformat": {
+                            "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Assign example</span></a>",
+                            "hasname": "true"
+                        },
+                        "id": 4,
+                        "module": "assign",
+                        "extraclasses": ""
+                    }
+                }
+            ],
+            "hascms": true
+        },
+        "ishidden": false,
+        "iscurrent": true,
+        "currentlink": "<span class=\"accesshide\">This topic</span>",
+        "completioninfo": "<span class=\"badge badge-primary\">Completion Info</span>",
+        "availability": {
+            "info": "<span class=\"badge badge-info\">Hidden from students</span>",
+            "hasavailability": true
+        },
+        "summary": {
+            "summarytext": "Summary text!"
+        },
+        "controlmenu": {
+            "menu": "<a href=\"#\" class=\"d-inline-block dropdown-toggle icon-no-margin\">Edit<b class=\"caret\"></b></a>",
+            "hasmenu": true
+        },
+        "cmcontrols": "[Add an activity or resource]"
+    }
+}}
+<li id="section-{{num}}"
+        class="section main {{#onlysummary}} section-summary {{/onlysummary}} clearfix
+              {{#ishidden}} hidden {{/ishidden}} {{#iscurrent}} current {{/iscurrent}}
+              {{#isstealth}} orphaned {{/isstealth}}"
+        role="region"
+        aria-labelledby="sectionid-{{id}}-title"
+        data-sectionid="{{num}}"
+        data-sectionreturnid="{{sectionreturnid}}">
+    {{#singleheader}} {{> core_course/local/section_format/header }} {{/singleheader}}
+    <div class="left side">{{#iscurrent}} {{{currentlink}}} {{/iscurrent}}</div>
+    <div class="right side">
+    {{#controlmenu}}
+            {{> core_course/local/section_format/controlmenu }}
+    {{/controlmenu}}
+    </div>
+    <div class="content">
+        {{#header}} {{> core_course/local/section_format/header }} {{/header}}
+        {{{completioninfo}}}
+        {{#availability}}
+            {{> core_course/local/section_format/availability }}
+        {{/availability}}
+        <div class="summary">
+        {{#summary}}
+            {{> core_course/local/section_format/summary }}
+        {{/summary}}
+        </div>
+        {{#cmsummary}} {{> core_course/local/section_format/cmsummary }} {{/cmsummary}}
+        {{#cmlist}} {{> core_course/local/section_format/cmlist }} {{/cmlist}}
+        {{{cmcontrols}}}
+    </div>
+</li>
diff --git a/course/templates/local/section_format/availability.mustache b/course/templates/local/section_format/availability.mustache
new file mode 100644
index 00000000000..de88d87dc8f
--- /dev/null
+++ b/course/templates/local/section_format/availability.mustache
@@ -0,0 +1,34 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/availability
+
+    Displays a section availability.
+
+    The 3.x version course edition requires an existing section_availability div.
+
+    Example context (json):
+    {
+        "info": "<span class=\"badge badge-info\">Hidden from students</span>",
+        "hasavailability": true
+    }
+}}
+<div class="section_availability">
+{{#hasavailability}}
+    {{{info}}}
+{{/hasavailability}}
+</div>
diff --git a/course/templates/local/section_format/cmitem.mustache b/course/templates/local/section_format/cmitem.mustache
new file mode 100644
index 00000000000..de9ec02cc19
--- /dev/null
+++ b/course/templates/local/section_format/cmitem.mustache
@@ -0,0 +1,43 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/cmitem
+
+    Displays the course module list inside a course section.
+
+    Example context (json):
+    {
+        "cmformat": {
+            "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Activity example</span></a>",
+            "hasname": "true",
+            "moveicon": "<i>[Move]</i>",
+            "indent": 2,
+            "afterlink": "<span class=\"badge badge-primary\">30 unread messages</span>",
+            "hasextras": true,
+            "extras": ["<span class=\"badge badge-secondary\">[extras]</span>"],
+            "completion": "<span class=\"badge badge-success\">Completed!</span>"
+        },
+        "id": 3,
+        "module": "forum",
+        "extraclasses": "newmessages"
+    }
+}}
+<li class="activity {{module}} modtype_{{module}} {{extraclasses}}" id="module-{{id}}">
+{{#cmformat}}
+    {{> core_course/local/cm_format}}
+{{/cmformat}}
+</li>
diff --git a/course/templates/local/section_format/cmlist.mustache b/course/templates/local/section_format/cmlist.mustache
new file mode 100644
index 00000000000..61c235f6463
--- /dev/null
+++ b/course/templates/local/section_format/cmlist.mustache
@@ -0,0 +1,77 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/cmlist
+
+    Displays the course module list inside a course section.
+
+    Example context (json):
+    {
+        "cms": [
+            {
+                "cmitem": {
+                    "cmformat": {
+                        "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Forum example</span></a>",
+                        "hasname": "true"
+                    },
+                    "id": 3,
+                    "module": "forum",
+                    "extraclasses": "newmessages"
+                }
+            },
+            {
+                "cmitem": {
+                    "cmformat": {
+                        "cmname": "<a class=\"aalink\" href=\"#\"><span class=\"instancename\">Assign example</span></a>",
+                        "hasname": "true"
+                    },
+                    "id": 3,
+                    "module": "assign",
+                    "extraclasses": ""
+                }
+            }
+        ],
+        "hascms": true,
+        "showmovehere": true,
+        "movingstr": "Moving this activity: folder example",
+        "cancelcopyurl": "#",
+        "movetosectionurl": "#",
+        "strmovefull": "Move 'folder example' to this location"
+    }
+}}
+{{#showmovehere}}
+<p>{{movingstr}} (<a href="{{{cancelcopyurl}}}">{{#str}} cancel {{/str}}</a>)</p>
+{{/showmovehere}}
+{{#hascms}}
+    <ul class="section img-text">
+    {{#cms}}
+        {{#showmovehere}}
+            <li class="movehere">
+                <a href="{{{moveurl}}}" title="{{strmovefull}}" class="movehere"></a>
+            </li>
+        {{/showmovehere}}
+        {{#cmitem}}
+            {{> core_course/local/section_format/cmitem}}
+        {{/cmitem}}
+    {{/cms}}
+    {{#showmovehere}}
+    <li class="movehere">
+        <a href="{{{movetosectionurl}}}" title="{{strmovefull}}" class="movehere"></a>
+    </li>
+    {{/showmovehere}}
+    </ul>
+{{/hascms}}
diff --git a/course/templates/local/section_format/cmsummary.mustache b/course/templates/local/section_format/cmsummary.mustache
new file mode 100644
index 00000000000..256805902e4
--- /dev/null
+++ b/course/templates/local/section_format/cmsummary.mustache
@@ -0,0 +1,44 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/cmsummary
+
+    Displays the activities summary of a section.
+
+    Example context (json):
+    {
+        "mods": [
+            {
+                "name": "Forums",
+                "count": "3"
+            },
+            {
+                "name": "Books",
+                "count": "2"
+            }
+        ],
+        "modprogress": "Total 5"
+    }
+}}
+<div class="section-summary-activities pr-2 mdl-right">
+    {{#mods}}
+    <span class="activity-count">{{name}}: {{count}}</span>
+    {{/mods}}
+</div>
+<div class="section-summary-activities pr-2 mdl-right">
+    <span class="activity-count">{{modprogress}}</span>
+</div>
diff --git a/course/templates/local/section_format/controlmenu.mustache b/course/templates/local/section_format/controlmenu.mustache
new file mode 100644
index 00000000000..eb62078b441
--- /dev/null
+++ b/course/templates/local/section_format/controlmenu.mustache
@@ -0,0 +1,32 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/controlmenu
+
+    Displays a section control menu (dropdown menu).
+
+    Example context (json):
+    {
+        "menu": "<a href=\"#\" class=\"d-inline-block dropdown-toggle icon-no-margin\">Edit<b class=\"caret\"></b></a>",
+        "hasmenu": true
+    }
+}}
+{{#hasmenu}}
+<div class="section_action_menu" data-sectionid="{{id}}">
+    {{{menu}}}
+</div>
+{{/hasmenu}}
diff --git a/course/templates/local/section_format/header.mustache b/course/templates/local/section_format/header.mustache
new file mode 100644
index 00000000000..8fb73916a5d
--- /dev/null
+++ b/course/templates/local/section_format/header.mustache
@@ -0,0 +1,37 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/header
+
+    Displays a course section header.
+
+    Example context (json):
+    {
+        "name": "Section title",
+        "url": "#",
+        "ishidden": true
+    }
+}}
+
+<h3 class="sectionid-{{id}}-title sectionname">
+    {{#url}}
+    <a href="{{{url}}}" class="{{#ishidden}} dimmed_text {{/ishidden}}">{{name}}</a>
+    {{/url}}
+    {{^url}}
+    <span>{{{title}}}</span>
+    {{/url}}
+</h3>
diff --git a/course/templates/local/section_format/summary.mustache b/course/templates/local/section_format/summary.mustache
new file mode 100644
index 00000000000..56176ddecc2
--- /dev/null
+++ b/course/templates/local/section_format/summary.mustache
@@ -0,0 +1,31 @@
+{{!
+    This file is part of Moodle - http://moodle.org/
+
+    Moodle is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Moodle is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+}}
+{{!
+    @template core_course/local/section_format/summary
+
+    Displays the course section summary.
+
+    Example context (json):
+    {
+        "summarytext": "Summary text!"
+    }
+}}
+{{#summarytext}}
+<div class="summarytext">
+    {{{summarytext}}}
+</div>
+{{/summarytext}}
diff --git a/course/tests/behat/paged_course_navigation.feature b/course/tests/behat/paged_course_navigation.feature
index 04b7b15b830..abc9a04f87c 100644
--- a/course/tests/behat/paged_course_navigation.feature
+++ b/course/tests/behat/paged_course_navigation.feature
@@ -17,18 +17,18 @@ Feature: Course paged mode
     And I am on "Course 1" course homepage
     And I click on <section1> "link" in the <section1> "section"
     And I should see <section1> in the "div.single-section" "css_element"
-    And I should see <section2> in the ".single-section span.mdl-right" "css_element"
+    And I should see <section2> in the ".single-section div.nextsection" "css_element"
     And I should not see <prevunexistingsection> in the ".single-section" "css_element"
     And I click on <section2> "link" in the ".single-section" "css_element"
     And I should see <section2> in the "div.single-section" "css_element"
-    And I should see <section1> in the ".single-section span.mdl-left" "css_element"
-    And I should see <section3> in the ".single-section span.mdl-right" "css_element"
+    And I should see <section1> in the ".single-section div.prevsection" "css_element"
+    And I should see <section3> in the ".single-section div.nextsection" "css_element"
     And I click on <section1> "link" in the ".single-section" "css_element"
     And I should see <section1> in the "div.single-section" "css_element"
     And I click on <section2> "link" in the ".single-section" "css_element"
     And I click on <section3> "link" in the ".single-section" "css_element"
     And I should see <section3> in the "div.single-section" "css_element"
-    And I should see <section2> in the ".single-section span.mdl-left" "css_element"
+    And I should see <section2> in the ".single-section div.prevsection" "css_element"
     And I should not see <section1> in the ".single-section .section-navigation" "css_element"
     And I should not see <prevunexistingsection> in the ".single-section" "css_element"
     And I should not see <nextunexistingsection> in the ".single-section" "css_element"
@@ -47,13 +47,13 @@ Feature: Course paged mode
     And I am on "Course 1" course homepage with editing mode on
     And I click on <section1> "link" in the <section1> "section"
     And I should see <section1> in the "div.single-section" "css_element"
-    And I should see <section2> in the ".single-section span.mdl-right" "css_element"
+    And I should see <section2> in the ".single-section div.nextsection" "css_element"
     And I should not see <prevunexistingsection> in the ".single-section" "css_element"
     When I add a "Chat" to section "1" and I fill the form with:
       | Name of this chat room | Chat room |
       | Description | Chat description |
     Then I should see <section1> in the "div.single-section" "css_element"
-    And I should see <section2> in the ".single-section span.mdl-right" "css_element"
+    And I should see <section2> in the ".single-section div.nextsection" "css_element"
     And I should not see <prevunexistingsection> in the ".single-section" "css_element"
 
     Examples:
@@ -73,18 +73,18 @@ Feature: Course paged mode
     And I am on "Course 1" course homepage
     And I click on <section1> "link" in the <section1> "section"
     And I should see <section1> in the "div.single-section" "css_element"
-    And I should see <section2> in the ".single-section span.mdl-right" "css_element"
+    And I should see <section2> in the ".single-section div.nextsection" "css_element"
     And I should not see <prevunexistingsection> in the ".single-section" "css_element"
     And I click on <section2> "link" in the ".single-section" "css_element"
     And I should see <section2> in the "div.single-section" "css_element"
-    And I should see <section1> in the ".single-section span.mdl-left" "css_element"
-    And I should see <section3> in the ".single-section span.mdl-right" "css_element"
+    And I should see <section1> in the ".single-section div.prevsection" "css_element"
+    And I should see <section3> in the ".single-section div.nextsection" "css_element"
     And I click on <section1> "link" in the ".single-section" "css_element"
     And I should see <section1> in the "div.single-section" "css_element"
     And I click on <section2> "link" in the ".single-section" "css_element"
     And I click on <section3> "link" in the ".single-section" "css_element"
     And I should see <section3> in the "div.single-section" "css_element"
-    And I should see <section2> in the ".single-section span.mdl-left" "css_element"
+    And I should see <section2> in the ".single-section div.prevsection" "css_element"
     And I should not see <section1> in the ".single-section .section-navigation" "css_element"
     And I should not see <prevunexistingsection> in the ".single-section" "css_element"
     And I should not see <nextunexistingsection> in the ".single-section" "css_element"
diff --git a/course/tests/fixtures/format_theunittest.php b/course/tests/fixtures/format_theunittest.php
index b53dfd872d0..5a209665efe 100644
--- a/course/tests/fixtures/format_theunittest.php
+++ b/course/tests/fixtures/format_theunittest.php
@@ -14,10 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-defined('MOODLE_INTERNAL') || die();
-
-require_once($CFG->dirroot . '/course/format/lib.php');
-
 /**
  * Fixture for fake course format testing course format API.
  *
@@ -25,7 +21,7 @@ require_once($CFG->dirroot . '/course/format/lib.php');
  * @copyright  2014 Marina Glancy
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class format_theunittest extends format_base {
+class format_theunittest extends core_course\course_format {
 
     /**
      * Definitions of the additional options that format uses
diff --git a/course/upgrade.txt b/course/upgrade.txt
index 69bf9230ad4..2a83f2f72fa 100644
--- a/course/upgrade.txt
+++ b/course/upgrade.txt
@@ -1,6 +1,50 @@
 This files describes API changes in /course/*,
 information provided here is intended especially for developers.
 
+=== 4.0 ===
+
+* The format_base is now deprecated. Use core_course\course_format instead.
+* The new course output components deprecate many renderer methods from course
+renderer and course format renderer:
+  - output\course_format: to render the general course structure
+  - output\section_format: to render a section
+  - output\cm_format: to render an activity card inside a section
+  - output\course_format\*: to render parts of the course structure
+  - output\section_format\*: to render parts of the course section
+* The previous format renderer page_title method has been moved to course_format::page_title
+* New format renderer methods to interact with the new output components:
+  - render: override the default templatable mustache location for the new course components.
+  - course_section_updated_cm_item: used when the course editor needs to update a cm item HTML.
+  - render_course_format: contrib formats should override this method to change the default template.
+* The following methods are adapted to use outputs but with a deprecation warning and should not be used anymore:
+  - print_single_section_page (replaced by output\course_format)
+  - print_multiple_section_page (replaced by output\course_format)
+  - course_activity_clipboard (integrated in replaced by output\course_format)
+  - format_summary_text (replaced by output\section_format\summay)
+  - change_number_sections (replaced by output\course_format\addsection)
+  - course_section_cm_list_item (replaced by output\section_format\cmitem)
+  - course_section_cm (replaced by output\cm_format)
+  - course_section_cm_list (replaced by output\section_format\cmlist)
+  - section_edit_control_menu (replaced by output\section_format\controlmenu)
+  - section_right_content (integrated in output\section_format)
+  - section_left_content (integrated in output\section_format)
+  - section_header (replaced by output\section_format\header)
+  - section_footer (integrated in output\section_format)
+  - section_edit_control_items (replaced by output\section_format\controlmenu)
+  - section_summary (replaced by output\section_format\summary)
+  - section_activity_summary (replaced by output\section_format\cmsummary)
+  - section_availability_message (integrated in output\section_format\availability)
+  - section_availability (replaced by output\section_format\availability)
+  - get_nav_links (replaced by output\course_format\sectionnavigation)
+  - stealth_section_header (replaced by output\section_format\header)
+  - stealth_section_footer (integrated in by output\section_format)
+  - section_nav_selection (replaced by output\course_format\sectionselector)
+* The following abstract methods are deleted:
+  - start_section_list (integrated in output\course_format)
+  - end_section_list (integrated in output\course_format)
+  - page_title (moved to output\course_format)
+
+
 === 3.10 ===
 
 * The function make_categories_options() has now been deprecated. Please use \core_course_category::make_categories_list() instead.
diff --git a/lib/deprecatedlib.php b/lib/deprecatedlib.php
index 1a2f3d94c5a..c1c2b8c3977 100644
--- a/lib/deprecatedlib.php
+++ b/lib/deprecatedlib.php
@@ -989,8 +989,8 @@ function make_editing_buttons() {
  * @deprecated since 2.5
  */
 function print_section() {
-    throw new coding_exception('Function print_section() is removed. Please use course renderer function '.
-            'course_section_cm_list() instead.');
+    throw new coding_exception('Function print_section() is removed. Please use core_course\output\section_format '.
+            ' to render a course section instead.');
 }
 
 /**
diff --git a/lib/navigationlib.php b/lib/navigationlib.php
index 494f745b26a..4af9f550eca 100644
--- a/lib/navigationlib.php
+++ b/lib/navigationlib.php
@@ -2005,11 +2005,11 @@ class global_navigation extends navigation_node {
      * Loads all of the courses section into the navigation.
      *
      * This function calls method from current course format, see
-     * {@link core_course\course_format::extend_course_navigation()}
+     * core_course\course_format::extend_course_navigation()
      * If course module ($cm) is specified but course format failed to create the node,
      * the activity node is created anyway.
      *
-     * By default course formats call the method {@link global_navigation::load_generic_course_sections()}
+     * By default course formats call the method global_navigation::load_generic_course_sections()
      *
      * @param stdClass $course Database record for the course
      * @param navigation_node $coursenode The course node within the navigation