diff --git a/lib/slideck/cli.rb b/lib/slideck/cli.rb
index 9a6edb0..b625e08 100644
--- a/lib/slideck/cli.rb
+++ b/lib/slideck/cli.rb
@@ -15,12 +15,13 @@ class CLI
       desc "Present Markdown-powered slide decks in the terminal"
 
       desc "Controls:",
-           "  First  ^",
-           "  Go to  1..n+g",
-           "  Last   $",
-           "  Next   n, l, Right, Spacebar",
-           "  Prev   p, h, Left, Backspace",
-           "  Quit   q, Esc"
+           "  First   ^",
+           "  Go to   1..n+g",
+           "  Last    $",
+           "  Next    n, l, Right, Spacebar",
+           "  Prev    p, h, Left, Backspace",
+           "  Reload  r, Ctrl+l",
+           "  Quit    q, Esc"
 
       example "Start presentation",
               "$ #{program} slides.md"
diff --git a/lib/slideck/presenter.rb b/lib/slideck/presenter.rb
index 827febd..e48fb43 100644
--- a/lib/slideck/presenter.rb
+++ b/lib/slideck/presenter.rb
@@ -7,8 +7,6 @@ module Slideck
   class Presenter
     # Create a Presenter
     #
-    # @param [Array<Hash>] slides
-    #   the slides to present
     # @param [TTY::Reader] reader
     #   the keyboard input reader
     # @param [Slideck::Renderer] renderer
@@ -17,14 +15,16 @@ class Presenter
     #   the tracker for slides
     # @param [IO] output
     #   the output stream for the slides
+    # @param [Proc] reloader
+    #   the metadata and slides reloader
     #
     # @api public
-    def initialize(slides, reader, renderer, tracker, output)
-      @slides = slides
+    def initialize(reader, renderer, tracker, output, &reloader)
       @reader = reader
       @renderer = renderer
       @tracker = tracker
       @output = output
+      @reloader = reloader
       @stop = false
       @buffer = []
     end
@@ -32,20 +32,14 @@ def initialize(slides, reader, renderer, tracker, output)
     # Reload presentation
     #
     # @example
-    #   renderer.reload(metadata, slides)
-    #
-    # @param [Slideck::Metadata] metadata
-    #   the slides metadata
-    # @param [Array<Hash>] slides
-    #   the slides to present
+    #   renderer.reload
     #
     # @return [Slideck::Presenter]
     #
     # @api public
-    def reload(metadata, slides)
-      @slides = slides
-      @renderer = @renderer.with_metadata(metadata)
-      @tracker = @tracker.resize(slides.size)
+    def reload
+      @metadata, @slides = *@reloader.()
+      @tracker = @tracker.resize(@slides.size)
       self
     end
 
@@ -58,6 +52,7 @@ def reload(metadata, slides)
     #
     # @api public
     def start
+      reload
       @reader.subscribe(self)
       hide_cursor
 
@@ -108,7 +103,10 @@ def clear_screen
     # @api private
     def render_slide
       @output.print @renderer.render(
-        @slides[@tracker.current], @tracker.current + 1, @tracker.total)
+        @metadata,
+        @slides[@tracker.current],
+        @tracker.current + 1,
+        @tracker.total)
     end
 
     # Hide cursor
@@ -145,6 +143,7 @@ def keypress(event)
       when "$" then go_to_last
       when "g" then go_to_slide
       when /\d/ then add_to_buffer(event.value)
+      when "r" then keyctrl_l
       when "q" then keyctrl_x
       end
     end
@@ -171,6 +170,15 @@ def keyleft(*)
     alias keybackspace keyleft
     alias keypage_up keyleft
 
+    # Reload presentation
+    #
+    # @return [void]
+    #
+    # @api private
+    def keyctrl_l(*)
+      reload
+    end
+
     # Exit presentation
     #
     # @return [void]
diff --git a/lib/slideck/renderer.rb b/lib/slideck/renderer.rb
index e78d1d9..b9d26ca 100644
--- a/lib/slideck/renderer.rb
+++ b/lib/slideck/renderer.rb
@@ -23,47 +23,30 @@ class Renderer
     #   the ansi codes handler
     # @param [TTY::Cursor] cursor
     #   the cursor navigation
-    # @param [Slideck::Metadata] metadata
-    #   the configuration metadata
     # @param [Integer] width
     #   the screen width
     # @param [Integer] height
     #   the screen height
     #
     # @api public
-    def initialize(converter, ansi, cursor, metadata, width: nil, height: nil)
+    def initialize(converter, ansi, cursor, width: nil, height: nil)
       @converter = converter
       @ansi = ansi
       @cursor = cursor
-      @metadata = metadata
       @width = width
       @height = height
 
       freeze
     end
 
-    # Create a Renderer with new metadata
-    #
-    # @example
-    #   renderer.with_metadata(metadata)
-    #
-    # @param [Slideck::Metadata] metadata
-    #   the configuration metadata
-    #
-    # @return [Slideck::Renderer]
-    #
-    # @api public
-    def with_metadata(metadata)
-      self.class.new(@converter, @ansi, @cursor, metadata,
-                     width: @width, height: @height)
-    end
-
     # Render a slide
     #
     # @example
-    #   renderer.render("slide content", 1, 5)
+    #   renderer.render(metadata, slide, 1, 5)
     #
-    # @param [String, nil] slide
+    # @param [Slideck::Metadata] metadata
+    #   the global metadata
+    # @param [Hash{Symbol => Hash, String}, nil] slide
     #   the current slide to render
     # @param [Integer] current_num
     #   the current slide number
@@ -73,12 +56,13 @@ def with_metadata(metadata)
     # @return [String]
     #
     # @api public
-    def render(slide, current_num, num_of_slides)
+    def render(metadata, slide, current_num, num_of_slides)
       slide_metadata = slide && slide[:metadata]
       [].tap do |out|
-        out << render_content(slide) if slide
-        out << render_footer(slide_metadata)
-        out << render_pager(slide_metadata, current_num, num_of_slides)
+        out << render_content(metadata, slide) if slide
+        out << render_footer(metadata, slide_metadata)
+        out << render_pager(metadata, slide_metadata,
+                            current_num, num_of_slides)
       end.join
     end
 
@@ -98,15 +82,18 @@ def clear
 
     # Render slide content
     #
-    # @param [String] slide
+    # @param [Slideck::Metadata] metadata
+    #   the global metadata
+    # @param [Hash{Symbol => Hash, String}] slide
     #   the slide to render
     #
     # @return [String]
     #
     # @api private
-    def render_content(slide)
+    def render_content(metadata, slide)
       alignment, margin, symbols, theme =
-        *select_metadata(slide[:metadata], :align, :margin, :symbols, :theme)
+        *select_metadata(metadata, slide[:metadata], :align, :margin,
+                         :symbols, :theme)
       converted = convert_markdown(slide[:content], margin, symbols, theme)
 
       render_section(converted.lines, alignment, margin)
@@ -114,19 +101,21 @@ def render_content(slide)
 
     # Render footer
     #
+    # @param [Slideck::Metadata] metadata
+    #   the global metadata
     # @param [Slideck::Metadata] slide_metadata
     #   the slide metadata
     #
     # @return [String]
     #
     # @api private
-    def render_footer(slide_metadata)
-      footer_metadata = pick_metadata(slide_metadata, :footer)
+    def render_footer(metadata, slide_metadata)
+      footer_metadata = pick_metadata(metadata, slide_metadata, :footer)
       return if (text = footer_metadata[:text]).empty?
 
-      alignment = footer_metadata[:align] || @metadata.footer[:align]
+      alignment = footer_metadata[:align] || metadata.footer[:align]
       margin, symbols, theme =
-        *select_metadata(slide_metadata, :margin, :symbols, :theme)
+        *select_metadata(metadata, slide_metadata, :margin, :symbols, :theme)
       converted = convert_markdown(text, margin, symbols, theme).chomp
 
       render_section(converted.lines, alignment, margin)
@@ -134,6 +123,8 @@ def render_footer(slide_metadata)
 
     # Render pager
     #
+    # @param [Slideck::Metadata] metadata
+    #   the global metadata
     # @param [Slideck::Metadata] slide_metadata
     #   the slide metadata
     # @param [Integer] current_num
@@ -144,13 +135,13 @@ def render_footer(slide_metadata)
     # @return [String]
     #
     # @api private
-    def render_pager(slide_metadata, current_num, num_of_slides)
-      pager_metadata = pick_metadata(slide_metadata, :pager)
+    def render_pager(metadata, slide_metadata, current_num, num_of_slides)
+      pager_metadata = pick_metadata(metadata, slide_metadata, :pager)
       return if (text = pager_metadata[:text]).empty?
 
-      alignment = pager_metadata[:align] || @metadata.pager[:align]
+      alignment = pager_metadata[:align] || metadata.pager[:align]
       margin, symbols, theme =
-        *select_metadata(slide_metadata, :margin, :symbols, :theme)
+        *select_metadata(metadata, slide_metadata, :margin, :symbols, :theme)
       formatted_text = format(text, page: current_num, total: num_of_slides)
       converted = convert_markdown(formatted_text, margin, symbols, theme).chomp
 
@@ -159,6 +150,8 @@ def render_pager(slide_metadata, current_num, num_of_slides)
 
     # Select configuration(s) by name(s) from metadata
     #
+    # @param [Slideck::Metadata] metadata
+    #   the global metadata
     # @param [Slideck::Metadata] slide_metadata
     #   the slide metadata
     # @param [Array<Symbol>] names
@@ -167,14 +160,16 @@ def render_pager(slide_metadata, current_num, num_of_slides)
     # @return [Array<Object>]
     #
     # @api private
-    def select_metadata(slide_metadata, *names)
+    def select_metadata(metadata, slide_metadata, *names)
       names.each_with_object([]) do |name, selected|
-        selected << pick_metadata(slide_metadata, name)
+        selected << pick_metadata(metadata, slide_metadata, name)
       end
     end
 
     # Pick configuration by name from metadata
     #
+    # @param [Slideck::Metadata] metadata
+    #   the global metadata
     # @param [Slideck::Metadata] slide_metadata
     #   the slide metadata
     # @param [Symbol] name
@@ -183,9 +178,9 @@ def select_metadata(slide_metadata, *names)
     # @return [Hash, Slideck::Alignment, Slideck::Margin, String, Symbol]
     #
     # @api private
-    def pick_metadata(slide_metadata, name)
+    def pick_metadata(metadata, slide_metadata, name)
       slide_metadata_item = slide_metadata && slide_metadata.send(name)
-      slide_metadata_item || @metadata.send(name)
+      slide_metadata_item || metadata.send(name)
     end
 
     # Render section with aligned lines
diff --git a/lib/slideck/runner.rb b/lib/slideck/runner.rb
index 6383bc0..cc9a64b 100644
--- a/lib/slideck/runner.rb
+++ b/lib/slideck/runner.rb
@@ -64,10 +64,10 @@ def initialize(screen, input, output, env)
     #
     # @api public
     def run(filename, color: nil, watch: nil)
-      presenter = build_presenter(*read_slides(filename), color)
+      presenter = build_presenter(color) { read_slides(filename) }
 
       if watch
-        listener = build_listener(presenter, filename)
+        listener = build_listener(filename) { presenter.reload.render }
         listener.start
       end
 
@@ -155,43 +155,37 @@ def build_metadata(custom_metadata, metadata_defaults)
 
     # Build presenter
     #
-    # @param [Slideck::Metadata] metadata
-    #   the configuration metadata
-    # @param [Array<Hash>] slides
-    #   the slides to present
     # @param [String, Symbol] color
     #   the color display out of always, auto or never
+    # @param [Proc] reloader
+    #   the metadata and slides reloader
     #
     # @return [Slideck::Presenter]
     #
     # @api private
-    def build_presenter(metadata, slides, color)
+    def build_presenter(color, &reloader)
       reader = TTY::Reader.new(input: @input, output: @output, env: @env,
                                interrupt: :exit)
       converter = Converter.new(TTY::Markdown, color: color)
-      renderer = Renderer.new(converter, Strings::ANSI, TTY::Cursor, metadata,
+      renderer = Renderer.new(converter, Strings::ANSI, TTY::Cursor,
                               width: @screen.width, height: @screen.height)
-      tracker = Tracker.for(slides.size)
-      Presenter.new(slides, reader, renderer, tracker, @output)
+      tracker = Tracker.for(0)
+      Presenter.new(reader, renderer, tracker, @output, &reloader)
     end
 
     # Build a listener for changes in a filename
     #
-    # @param [Slideck::Presenter] presenter
-    #   the presenter for slides
     # @param [String] filename
     #   the filename with slides
     #
     # @return [Listen::Listener]
     #
     # @api private
-    def build_listener(presenter, filename)
+    def build_listener(filename)
       watched_dir = File.expand_path(File.dirname(filename))
       watched_file = File.expand_path(filename)
       Listen.to(watched_dir) do |changed_files, _, _|
-        if changed_files.include?(watched_file)
-          presenter.reload(*read_slides(filename)).render
-        end
+        yield if changed_files.include?(watched_file)
       end
     end
   end # Runner
diff --git a/spec/unit/cli_spec.rb b/spec/unit/cli_spec.rb
index 365464c..0f69469 100644
--- a/spec/unit/cli_spec.rb
+++ b/spec/unit/cli_spec.rb
@@ -106,12 +106,13 @@
       Present Markdown-powered slide decks in the terminal
 
       Controls:
-        First  ^
-        Go to  1..n+g
-        Last   $
-        Next   n, l, Right, Spacebar
-        Prev   p, h, Left, Backspace
-        Quit   q, Esc
+        First   ^
+        Go to   1..n+g
+        Last    $
+        Next    n, l, Right, Spacebar
+        Prev    p, h, Left, Backspace
+        Reload  r, Ctrl+l
+        Quit    q, Esc
 
       Options:
             --color WHEN  When to color output (permitted: always, auto, never)
diff --git a/spec/unit/presenter_spec.rb b/spec/unit/presenter_spec.rb
index e81478c..fbbe631 100644
--- a/spec/unit/presenter_spec.rb
+++ b/spec/unit/presenter_spec.rb
@@ -26,13 +26,15 @@ def build_metadata(custom_metadata)
         {content: "slide#{i + 1}", metadata: slide_metadata}
       end
       tracker = Slideck::Tracker.for(slides.size)
-      renderer = Slideck::Renderer.new(converter, ansi, cursor, metadata,
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
                                        width: 20, height: 8)
-      presenter = described_class.new(slides, reader, renderer, tracker, output)
       reloaded_metadata = build_metadata({theme: {strong: :cyan}})
       reloaded_slides = [{content: "**Reloaded**", metadata: slide_metadata}]
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        [reloaded_metadata, reloaded_slides]
+      end
 
-      presenter.reload(reloaded_metadata, reloaded_slides).render
+      presenter.reload.render
 
       expect(output.string.inspect).to eq([
         "\e[2J\e[1;1H",
@@ -48,9 +50,11 @@ def build_metadata(custom_metadata)
                 {content: "slide2", metadata: slide_metadata},
                 {content: "slide3", metadata: slide_metadata}]
       tracker = Slideck::Tracker.for(slides.size)
-      renderer = Slideck::Renderer.new(converter, ansi, cursor, metadata,
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
                                        width: 20, height: 8)
-      presenter = described_class.new(slides, reader, renderer, tracker, output)
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        [metadata, slides]
+      end
       input << "q"
       input.rewind
 
@@ -69,9 +73,11 @@ def build_metadata(custom_metadata)
                 {content: "slide2", metadata: slide_metadata},
                 {content: "slide3", metadata: slide_metadata}]
       tracker = Slideck::Tracker.for(slides.size)
-      renderer = Slideck::Renderer.new(converter, ansi, cursor, metadata,
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
                                        width: 20, height: 8)
-      presenter = described_class.new(slides, reader, renderer, tracker, output)
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        [metadata, slides]
+      end
       input << "n" << "l" << "p" << "h" << ?\C-x
       input.rewind
 
@@ -102,9 +108,11 @@ def build_metadata(custom_metadata)
                 {content: "slide2", metadata: slide_metadata},
                 {content: "slide3", metadata: slide_metadata}]
       tracker = Slideck::Tracker.for(slides.size)
-      renderer = Slideck::Renderer.new(converter, ansi, cursor, metadata,
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
                                        width: 20, height: 8)
-      presenter = described_class.new(slides, reader, renderer, tracker, output)
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        [metadata, slides]
+      end
       reader.on(:keypress) do |event|
         reader.trigger(:keyleft) if event.value == "a"
         reader.trigger(:keyright) if event.value == "d"
@@ -148,9 +156,11 @@ def build_metadata(custom_metadata)
                 {content: "slide2", metadata: slide_metadata},
                 {content: "slide3", metadata: slide_metadata}]
       tracker = Slideck::Tracker.for(slides.size)
-      renderer = Slideck::Renderer.new(converter, ansi, cursor, metadata,
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
                                        width: 20, height: 8)
-      presenter = described_class.new(slides, reader, renderer, tracker, output)
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        [metadata, slides]
+      end
       input << "$" << "^" << "\e"
       input.rewind
 
@@ -175,9 +185,11 @@ def build_metadata(custom_metadata)
         {content: "slide#{i + 1}", metadata: slide_metadata}
       end
       tracker = Slideck::Tracker.for(slides.size)
-      renderer = Slideck::Renderer.new(converter, ansi, cursor, metadata,
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
                                        width: 20, height: 8)
-      presenter = described_class.new(slides, reader, renderer, tracker, output)
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        [metadata, slides]
+      end
       input << "1" << "3" << "g" << "q" << ?\C-c
       input.rewind
 
@@ -199,5 +211,38 @@ def build_metadata(custom_metadata)
         "\e[2J\e[1;1H\e[?25h"
       ].join.inspect)
     end
+
+    it "reloads slides with the 'r' and Ctrl+L keys and quits" do
+      slides = [{content: "slide1", metadata: slide_metadata},
+                {content: "slide2", metadata: slide_metadata}]
+      tracker = Slideck::Tracker.for(slides.size)
+      renderer = Slideck::Renderer.new(converter, ansi, cursor,
+                                       width: 20, height: 8)
+      i = -1
+      presenter = described_class.new(reader, renderer, tracker, output) do
+        if (i += 1).zero?
+          [metadata, slides]
+        else
+          [metadata, [{content: "reloaded#{i}", metadata: slide_metadata}]]
+        end
+      end
+      input << "r" << ?\C-l << "q"
+      input.rewind
+
+      presenter.start
+
+      expect(output.string.inspect).to eq([
+        "\e[?25l\e[2J\e[1;1H",
+        "\e[1;1Hslide1\n",
+        "\e[8;16H1 / 2",
+        "\e[2J\e[1;1H",
+        "\e[1;1Hreloaded1\n",
+        "\e[8;16H1 / 1",
+        "\e[2J\e[1;1H",
+        "\e[1;1Hreloaded2\n",
+        "\e[8;16H1 / 1",
+        "\e[2J\e[1;1H\e[?25h"
+      ].join.inspect)
+    end
   end
 end
diff --git a/spec/unit/renderer_spec.rb b/spec/unit/renderer_spec.rb
index 0940e54..c843b4b 100644
--- a/spec/unit/renderer_spec.rb
+++ b/spec/unit/renderer_spec.rb
@@ -18,63 +18,46 @@ def build_slide_metadata(custom_metadata)
     Slideck::Metadata.from(meta_converter, custom_metadata, {})
   end
 
-  describe "#with_metadata" do
-    it "creates an instance with new metadata" do
-      metadata = build_metadata({pager: ""})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
-                                     width: 20, height: 8)
-      new_metadata = build_metadata({footer: "footer"})
-      slide = {content: "content", metadata: build_slide_metadata({})}
-
-      new_renderer = renderer.with_metadata(new_metadata)
-
-      expect(new_renderer.render(slide, 1, 1).inspect).to eq([
-        "\e[1;1Hcontent\n",
-        "\e[8;1Hfooter\e[8;16H1 / 1"
-      ].join.inspect)
-    end
-  end
-
   describe "#render" do
     it "renders page number without slide content" do
       metadata = build_metadata({})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(nil, 0, 0).inspect).to eq([
+      expect(renderer.render(metadata, nil, 0, 0).inspect).to eq([
         "\e[8;16H0 / 0"
       ].join.inspect)
     end
 
     it "renders footer without slide content and pager" do
       metadata = build_metadata({footer: "footer", pager: ""})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(nil, 0, 0).inspect).to eq([
+      expect(renderer.render(metadata, nil, 0, 0).inspect).to eq([
         "\e[8;1Hfooter"
       ].join.inspect)
     end
 
     it "renders slide content without footer and pager" do
       metadata = build_metadata({footer: "", pager: ""})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 0, 0).inspect).to eq([
+      expect(renderer.render(metadata, slide, 0, 0).inspect).to eq([
         "\e[1;1Hcontent\n"
       ].join.inspect)
     end
 
     it "renders multiline content with page number" do
       metadata = build_metadata({})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "line1\nline2\nline3",
                metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hline1\n",
         "\e[2;1Hline2\n",
         "\e[3;1Hline3\n",
@@ -95,11 +78,11 @@ def build_slide_metadata(custom_metadata)
     }.each do |align, pos|
       it "renders slide with content at #{align.inspect}" do
         metadata = build_metadata({align: align})
-        renderer = described_class.new(converter, ansi, cursor, metadata,
+        renderer = described_class.new(converter, ansi, cursor,
                                        width: 20, height: 8)
         slide = {content: "content", metadata: build_slide_metadata({})}
 
-        expect(renderer.render(slide, 1, 4).inspect).to eq([
+        expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
           "\e[#{pos}Hcontent\n",
           "\e[8;16H1 / 4"
         ].join.inspect)
@@ -108,11 +91,11 @@ def build_slide_metadata(custom_metadata)
 
     it "renders content with a margin" do
       metadata = build_metadata({margin: [1, 2, 3, 4]})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 10)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[2;5Hcontent\n",
         "\e[7;14H1 / 4"
       ].join.inspect)
@@ -120,12 +103,12 @@ def build_slide_metadata(custom_metadata)
 
     it "renders multiline content with a margin" do
       metadata = build_metadata({margin: [1, 2, 3, 4]})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 10)
       slide = {content: "line1\nline2\nline3",
                metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[2;5Hline1\n",
         "\e[3;5Hline2\n",
         "\e[4;5Hline3\n",
@@ -135,12 +118,12 @@ def build_slide_metadata(custom_metadata)
 
     it "renders long content with a margin" do
       metadata = build_metadata({margin: [1, 2, 3, 4]})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 10)
       slide = {content: "It is not down on any map; true places never are.",
                metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[2;5HIt is not \n",
         "\e[3;5Hdown on any \n",
         "\e[4;5Hmap; true \n",
@@ -155,11 +138,11 @@ def build_slide_metadata(custom_metadata)
         footer: "footer",
         margin: [1, 2, 3, 4]
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 10)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[2;5Hcontent\n",
         "\e[7;5Hfooter",
         "\e[7;14H1 / 4"
@@ -168,7 +151,7 @@ def build_slide_metadata(custom_metadata)
 
     it "renders a markdown list" do
       metadata = build_metadata({})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       content = unindent(<<-EOS)
         # List
@@ -178,7 +161,7 @@ def build_slide_metadata(custom_metadata)
       EOS
       slide = {content: content, metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[36;1;4mList\e[0m\n",
         "\e[2;1H\e[33m●\e[0m a\n",
         "\e[3;1H\e[33m●\e[0m b\n",
@@ -190,7 +173,7 @@ def build_slide_metadata(custom_metadata)
     it "renders a markdown list without colors" do
       metadata = build_metadata({})
       converter = Slideck::Converter.new(markdown, color: :never)
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       content = unindent(<<-EOS)
         # List
@@ -200,7 +183,7 @@ def build_slide_metadata(custom_metadata)
       EOS
       slide = {content: content, metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1HList\n",
         "\e[2;1H● a\n",
         "\e[3;1H● b\n",
@@ -213,7 +196,7 @@ def build_slide_metadata(custom_metadata)
       metadata = build_metadata({
         symbols: :ascii
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       content = unindent(<<-EOS)
         # List
@@ -223,7 +206,7 @@ def build_slide_metadata(custom_metadata)
       EOS
       slide = {content: content, metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[36;1;4mList\e[0m\n",
         "\e[2;1H\e[33m*\e[0m a\n",
         "\e[3;1H\e[33m*\e[0m b\n",
@@ -240,7 +223,7 @@ def build_slide_metadata(custom_metadata)
           }
         }
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       content = unindent(<<-EOS)
         # List
@@ -250,7 +233,7 @@ def build_slide_metadata(custom_metadata)
       EOS
       slide = {content: content, metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[36;1;4mList\e[0m\n",
         "\e[2;1H\e[33mx\e[0m a\n",
         "\e[3;1H\e[33mx\e[0m b\n",
@@ -266,7 +249,7 @@ def build_slide_metadata(custom_metadata)
           list: :green
         }
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
       content = unindent(<<-EOS)
@@ -277,7 +260,7 @@ def build_slide_metadata(custom_metadata)
       EOS
       slide = {content: content, metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[35;4mList\e[0m\n",
         "\e[2;1H\e[32m●\e[0m a\n",
         "\e[3;1H\e[32m●\e[0m b\n",
@@ -288,11 +271,11 @@ def build_slide_metadata(custom_metadata)
 
     it "renders content with footer and page number" do
       metadata = build_metadata({footer: "footer"})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;1Hfooter\e[8;16H1 / 4"
       ].join.inspect)
@@ -300,11 +283,11 @@ def build_slide_metadata(custom_metadata)
 
     it "renders content with footer in markdown and page number" do
       metadata = build_metadata({footer: "**bold** footer"})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;1H\e[33;1mbold\e[0m footer\e[8;16H1 / 4"
       ].join.inspect)
@@ -316,11 +299,11 @@ def build_slide_metadata(custom_metadata)
         footer: "- footer",
         pager: "- %<page>d of %<total>d"
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "- content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[33m*\e[0m content\n",
         "\e[8;1H\e[33m*\e[0m footer",
         "\e[8;13H\e[33m*\e[0m 1 of 4"
@@ -336,11 +319,11 @@ def build_slide_metadata(custom_metadata)
           strong: %i[magenta underline]
         }
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;1H\e[35;4mfooter\e[0m",
         "\e[8;16H\e[36m1 / 4\e[0m"
@@ -349,11 +332,11 @@ def build_slide_metadata(custom_metadata)
 
     it "renders content and page number with markdown" do
       metadata = build_metadata({pager: "**%<page>s of %<total>s**"})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;15H\e[33;1m1 of 4\e[0m"
       ].join.inspect)
@@ -366,11 +349,11 @@ def build_slide_metadata(custom_metadata)
           text: "footer"
         }
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;8Hfooter\e[8;16H1 / 4"
       ].join.inspect)
@@ -393,11 +376,11 @@ def build_slide_metadata(custom_metadata)
             text: "%<page>d of %<total>d"
           }
         })
-        renderer = described_class.new(converter, ansi, cursor, metadata,
+        renderer = described_class.new(converter, ansi, cursor,
                                        width: 20, height: 8)
         slide = {content: "content", metadata: build_slide_metadata({})}
 
-        expect(renderer.render(slide, 1, 4).inspect).to eq([
+        expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
           "\e[1;1Hcontent\n",
           "\e[#{footer[:pos]}Hfooter\e[#{pager[:pos]}H1 of 4"
         ].join.inspect)
@@ -412,11 +395,11 @@ def build_slide_metadata(custom_metadata)
         },
         pager: ""
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;15Hfooter"
       ].join.inspect)
@@ -432,11 +415,11 @@ def build_slide_metadata(custom_metadata)
           text: "%<page>d\n%<total>d"
         }
       })
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
       slide = {content: "content", metadata: build_slide_metadata({})}
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[6;7Hfooter1\n",
         "\e[7;7Hfooter2\n",
@@ -467,10 +450,10 @@ def build_slide_metadata(custom_metadata)
         }
       })
       slide = {content: "content", metadata: slide_metadata}
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[3;11Hcontent\n",
         "\e[5;5Hslide footer",
         "\e[5;9H1 of 4"
@@ -489,10 +472,10 @@ def build_slide_metadata(custom_metadata)
         pager: ""
       })
       slide = {content: "content", metadata: slide_metadata}
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n"
       ].join.inspect)
     end
@@ -511,10 +494,10 @@ def build_slide_metadata(custom_metadata)
         }
       })
       slide = {content: "content", metadata: slide_metadata}
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1Hcontent\n",
         "\e[8;1Hslide footer",
         "\e[8;15H1 of 4"
@@ -535,10 +518,10 @@ def build_slide_metadata(custom_metadata)
         }
       })
       slide = {content: "- content", metadata: slide_metadata}
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[33mx\e[0m content\n",
         "\e[8;1H\e[33mx\e[0m footer",
         "\e[8;13H\e[33mx\e[0m 1 of 4"
@@ -558,10 +541,10 @@ def build_slide_metadata(custom_metadata)
         }
       })
       slide = {content: "# content", metadata: slide_metadata}
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
-      expect(renderer.render(slide, 1, 4).inspect).to eq([
+      expect(renderer.render(metadata, slide, 1, 4).inspect).to eq([
         "\e[1;1H\e[35;4mcontent\e[0m\n",
         "\e[8;1H\e[32mfooter\e[0m",
         "\e[8;15H\e[36m1 of 4\e[0m"
@@ -571,8 +554,7 @@ def build_slide_metadata(custom_metadata)
 
   describe "#clear" do
     it "clears screen" do
-      metadata = build_metadata({})
-      renderer = described_class.new(converter, ansi, cursor, metadata,
+      renderer = described_class.new(converter, ansi, cursor,
                                      width: 20, height: 8)
 
       expect(renderer.clear).to eq("\e[2J\e[1;1H")