How to display a rotated table over several pages?

fdekerm · December 5, 2024, 10:26am

Hello,
I have a very large table that I’d like to display on several pages. The following code :

#set page("a4", margin: (
  left: 1cm, 
  bottom: 1cm,
  top: 1cm,
  right: 1cm), 
  flipped: false)


#rotate(
  -90deg,
  reflow: true)[#figure(
 block(width: 100%, breakable: true, (table( 
    columns: (auto, auto, auto, auto, auto, auto, auto, auto, auto,),
    align: (left,left,left,left,left,left,left,left,left,),
    table.header([Type of model and
      outputs], [Model name and/or
      references], [...

gives this:

How can I make the rotated table spread over several pages?
Thank you,
fdekerm

gezepi · December 5, 2024, 12:43pm

My first thought to address this was instead of rotating the figure, rotate the page with #set page(flipped: true). I tried that and it did not improve the situation:

#set page("a6")
#let numCols = 6
#let numRows = 15

#let testTable = table( 
  columns: (auto,)*numCols,
  align: (left,left,left,left,left,left,left,left,left,),
  
  table.header(..(lorem(2),)*numCols),
  ..(..("data",)*numCols,)*numRows
)

#set page(flipped: true)

#figure(
  block(width: 100%, breakable: true,
    testTable,
  )
)

Output

But if the same table is used outside of a figure, it works as expected:

#set page("a6")
#let numCols = 6
#let numRows = 15

#let testTable = table( 
  columns: (auto,)*numCols,
  align: (left,left,left,left,left,left,left,left,left,),
  
  table.header(..(lorem(2),)*numCols),
  ..(..("data",)*numCols,)*numRows
)

preamble text
#set page(flipped: true)

#testTable

Output

And changing orientation of the page works nicely:

Normal orientation
#set page(flipped: true)
#testTable
#set page(flipped: false)
Again, normal orientation

Output

So, it seems figures do not handle spilling into a new page well.

PgBiel · December 5, 2024, 1:33pm

Figures are unbreakable by default (regardless of whether a block(breakable: true) is used in its body). You can use #show figure.where(kind: table): set block(breakable: true) to change this. (Though note that, for now, the figure caption won’t be repeated. There is some discussion and even a PR to change this, but it isn’t done yet.)

See also “Figure Behavior” in Figure Function – Typst Documentation

nmb · September 9, 2025, 1:39pm

I know that this is marked as solved but for me this doesn’t seem to work. My code looks basically like this

#show figure.where(kind: table): set block(breakable: true)

#let table_x = csv(
  "table.csv",
)
#rotate(
  -90deg,
  reflow: true,
)[
  #figure(
    table(
      columns: table_x.first().len(),
      table.header(repeat: true, ..table_x.first()),
      ..table_x.slice(1).flatten(),
    ),
    caption: [My Caption.],
  )
]

but the table does not split across pages.

I want to rotate the table not the pages themselves due to headers/footers in my document.

pilzi · July 2, 2026, 9:30am

Hi,
I would also be very interested in an answer to this, as I have the same problem of a rotated table that needs to break across several pages and my page header and footer need to stay in place. Has anyone an idea on how to do this?

gezepi · July 2, 2026, 10:55am

I wondered if it would be possible to achieve this with the new bundle feature that 0.15 introduced. The answer, unfortunately, is not really.

The idea is to output two PDFs. One with the table, and the main document that loads the table PDF via #image(). The table file compiles fine but the main document does not. If you use typst watch it actually loops continuously but never outputs a new main.pdf.

But the same idea can be applied with two normally compiled PDF files. First generate the table PDF, then include that in the main PDF. Here’s what that could look like:

large-table.pdf

#let numCols = 5
#let numRows = 30
#set page(flipped: true, margin: 0mm)

#let testTable = table( 
  columns: (auto,)*numCols,
  
  table.header(..(lorem(2),)*numCols),
  ..(..("data",)*numCols,)*numRows
)

#show figure.where(kind: table): set block(breakable: true)

#figure(
  kind: table,
  caption: [A big table],
  testTable
)

main.pdf

#set page("a6")
#set page(
  header: align(right)[Header text],
  footer: context align(right)[#counter(page).get().last() / #counter(page).final().last()]
)

#let show-large-table(file-path, num-pages) = {
  set rotate(-90deg)
  set align(center + horizon)
  for page-num in range(num-pages) {
    page(rotate(image(file-path, page: page-num + 1)))
  }
}
#lorem(20)
#show-large-table("TableRotate/large-tabel.pdf", 2)
#lorem(20)

The downsides are:

Two documents need to be maintained and compiled (in the correct order!)
Actual page sizing may be an issue since an A6 page is imported into an A6 page that already has space reserved for margins
Referencing this table will not work
This table will not show up in a table of contents
Any styling in the main document will not be applied to the table document

Possible fixes:

2 - the table document should have a page size that is the main page size minus margins.
3, 4 - could probably be fixed by changing show-large-table() to include the PDF as a figure with no caption but a label. Label names would need to be matched between the two documents
5 - A template could be used to manage styling

gezepi · July 2, 2026, 2:27pm

Here’s a more reasonable attempt. It inserts a page(s) with headers and footers that use place() to move the header/footer content to the sides of the page to make it look like real header/footers. The placements are not perfect. I probably forgot something and I was definitely getting confused with what is width and what is height.

#let header-content() = {
  set align(bottom)
  align(right)[Header text]
}
#let footer-content() = {
  set align(right + top)
  let x = [#counter(page).get().last() / #counter(page).final().last()]
  x
}

#set page("a6")
#set page(
  header: header-content(),
  footer: context footer-content()
)

#show figure.where(kind: table): set block(breakable: true)

#let numCols = 5
#let numRows = 15
#let testTable = table( 
  columns: (auto,)*numCols,
  
  table.header(..range(numCols).map(c => [Column #(c + 1)])),
  ..(..("data",)*numCols,)*numRows
)

#lorem(20)

#let x = page(context {
  //Get some dimensions for later.  This should be more complicated to handle all cases
  let margin-size = 2.5 / 21 * calc.min(page.width, page.height)
  let header-width = page.width - margin-size - margin-size
  
  set rect(width: header-width)
  set rect(stroke: none)
  set rotate(reflow: true)
  set rotate(90deg)

  set page("a6")
  set page(flipped: true)
  set page(header: place(
    right,
    float: false,
    dy: header-width + page.header-ascent,
    dx: margin-size,
    rotate(rect(
      height: margin-size,
      header-content()
    ))
  ))
  set page(footer: place(
      left,
      dy: -header-width - page.footer-descent,
      dx: -margin-size,
      rotate(rect(
        height: margin-size,
        context footer-content()
      ))
    )
  )
  
  figure(
    kind: table,
    caption: [A big table],
    testTable
  )
}).children.at(2)
#x

#lorem(20)

pilzi · July 9, 2026, 3:41pm

Hi, thanks a lot, this helped. Unfortunately, I always have an empty not-flipped page in front (showing header and footer only). I think it may have to do with the context, but I honestly don’t understand this. Adding a pagebreak(), doesn’t add another empty page before the flipped pages. Any ideas what the problem could be?

gezepi · July 10, 2026, 10:13am

Just to clarify: In your document you want to have a blank page before any such rotated pages, correct?

I believe the reason is because inserting the large table already creates a new page so the compiler/layouter decides that the user’s request to break to a new page will be fulfilled. It can be “avoided” by simply asking for another page break:

#lorem(20)

#pagebreak()
#pagebreak()

#insert-large-table(testTable)

#lorem(20)

Full code including re-usable `insert-large-table()`

#let header-content() = {
  set align(bottom)
  align(right)[Header text]
}
#let footer-content() = {
  set align(right + top)
  let x = [#counter(page).get().last() / #counter(page).final().last()]
  x
}

#set page("a6")
#set page(
  header: header-content(),
  footer: context footer-content()
)

#show figure.where(kind: table): set block(breakable: true)

#let numCols = 5
#let numRows = 15
#let testTable = table( 
  columns: (auto,)*numCols,
  
  table.header(..range(numCols).map(c => [Column #(c + 1)])),
  ..(..("data",)*numCols,)*numRows
)

#let insert-large-table(table-data) = page(context {
  //Get some dimensions for later.  This should be more complicated to handle all cases
  let margin-size = 2.5 / 21 * calc.min(page.width, page.height)
  let header-width = page.width - margin-size - margin-size
  
  set rect(width: header-width)
  set rect(stroke: none)
  set rotate(reflow: true)
  set rotate(90deg)

  set page("a6")
  set page(flipped: true)
  set page(header: place(
    right,
    float: false,
    dy: header-width + page.header-ascent,
    dx: margin-size,
    rotate(rect(
      height: margin-size,
      header-content()
    ))
  ))
  set page(footer: place(
      left,
      dy: -header-width - page.footer-descent,
      dx: -margin-size,
      rotate(rect(
        height: margin-size,
        context footer-content()
      ))
    )
  )
  
  figure(
    kind: table,
    caption: [A big table],
    table-data
  )
}).children.at(2)

#lorem(20)

#pagebreak()
#pagebreak()

#insert-large-table(testTable)

#lorem(20)

pilzi · July 10, 2026, 11:52am

Hi, sorry for the misunderstanding. I don’t want an empty page but I do have one, no matter what I do. My code is as follows:

Some things I have do say...

#page(context {
  let header-width = page.width - 2.5cm - 2cm
  set rect(width: header-width)
  set rect(stroke: none)
  set rotate(reflow: true)
  set rotate(90deg)
  set page(flipped: true)
  set page(margin: if calc.odd(here().page()) {(right: auto, left: auto, top: 2.5cm, bottom: 2cm)} else {(right: auto, left: auto, top: 2cm, bottom: 2.5cm)})
  set page(header: context place(
    right,
    dy: if calc.odd(here().page()) {header-width + page.header-ascent} else {header-width + page.header-ascent},
    dx: 2cm,
    rotate(rect(
      height: 2cm,
      width: header-width,
      header_content
    ))
  ))
  set page(footer: context place(
      left,
      dy: if calc.odd(here().page()) {-header-width - 2*page.footer-descent} else {-header-width - 2*page.footer-descent},
      dx: -2cm,
      rotate(rect(
        height: 2cm,
        width: header-width,
        footer_content
      ))
    )
  )
  [#show figure.where(kind: table): set block(breakable: true)
  #figure(
    table(
      columns: 3,
      manually-set-table-cells
    ),
    caption: [Caption],
  ) <label>
]})

More things I have to say...

I did the margin sizes manually because I’m using the (inside:…, outside:…) version of the margin for printing and I only have one case where I need to use this method to show a very long and very broad table.
I don’t have a random empty page after the table.

gezepi · July 10, 2026, 2:02pm

Took me a while to find it but mine doesn’t have an extra page because of this

#page(
  /**/
).children.at(2)

The page function itself returns more than is desired here. Its children:

(
  pagebreak(weak: true),
  flush(),
  context(),
  pagebreak(weak: true),
)

pilzi · July 10, 2026, 3:16pm

Thanks a lot, this made the random empty page disappear!
But I have to admit I don’t understand exactly what happens here. Could you explain this again please?

gezepi · July 10, 2026, 8:50pm

When you add #page() to your document it’s not just a pgae but the whole list in my last post that is added.

a new page is requested
floating figures are flushed (force placed)
the page itself. Here it just shows context
a new page is requested

.children.at(2) pulls only the third element (the page) from the list. The others never get placed in the document.

Josef · August 16, 2026, 3:52pm

the following code worked for me for a rotated multipage table.

Looks like:

You do not even need to put it in a separate .typ file.
All text before and after is within the regular vertical page context.
No unnecessary blank page created
The regular document page number appears on every rotated table page as well.

#{
  set page(flipped: true)

  show figure: set block(breakable: true)

  figure(
    table(
      columns: 3,

      [Column 1],
      [Column 2],
      [Column 3],

      [Row 1 \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d],
      [A],
      [B],

      [Row 2], [C], [D],
      [Row 3], [E], [F],
      [Row 4], [G], [H],
      [Row 5], [I], [J],
      [Row 6], [K], [L],
      [Row 7], [M], [N],
      [Row 8], [O], [P],
      [Row 9], [Q], [R],
      [Row 10], [S], [T],
    ),
    caption: [Basic breakable table],
  )
}

in the above code replace this part


      [Column 1],
      [Column 2],
      [Column 3],

      [Row 1 \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d],
      [A],
      [B],

      [Row 2], [C], [D],
      [Row 3], [E], [F],
      [Row 4], [G], [H],
      [Row 5], [I], [J],
      [Row 6], [K], [L],
      [Row 7], [M], [N],
      [Row 8], [O], [P],
      [Row 9], [Q], [R],
      [Row 10], [S], [T],

with your actual table. This is just to illustrate a table with a really long cell.

Josef · August 16, 2026, 4:12pm

If you want to have a version of the above with a repeated header row, use the following instead:

#{
  set page(flipped: true)

  show figure: set block(breakable: true)

  figure(
    table(
      columns: 3,

      table.header(
        repeat: true,
        [Column 1],
        [Column 2],
        [Column 3],
      ),

      [Row 1 \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d],
      [A],
      [B],

      [Row 2], [C], [D],
      [Row 3], [E], [F],
      [Row 4], [G], [H],
      [Row 5], [I], [J],
      [Row 6], [K], [L],
      [Row 7], [M], [N],
      [Row 8], [O], [P],
      [Row 9], [Q], [R],
      [Row 10], [S], [T],
    ),
    caption: [Basic breakable table],
  )
}

Josef · August 16, 2026, 4:15pm

And if you want to also have “Table continued on next page” text under each table break and a styled header row, use this:

#let table-counter = counter("_table_continuation")

#let table-continuation-style(body) = {
  show table: it => table-counter.step() + it
  body
}

#let footcounter() = counter(
  "_table_continuation_footer:" + str(table-counter.get().first())
)

#let continuation-footer(cont) = {
  table.footer(
    table.cell(
      colspan: 3,
      inset: (
        top: 8pt,
        bottom: 0pt,
        left: 0pt,
        right: 0pt,
      ),
      stroke: none,
      context {
        let counter = footcounter()
        counter.step()

        let current = 1 + counter.get().first()
        let final = counter.final().first()

        if current < final {
          cont
        }
      },
    )
  )
}

#{
  set page(flipped: true)

  show: table-continuation-style
  show figure: set block(breakable: true)

  figure(
    table(
      columns: 3,

      // Repeated, styled header
      table.header(
        repeat: true,

        table.cell(
          fill: luma(230),
          inset: 6pt,
          align: center + horizon,
          [*Column 1*],
        ),

        table.cell(
          fill: luma(230),
          inset: 6pt,
          align: center + horizon,
          [*Column 2*],
        ),

        table.cell(
          fill: luma(230),
          inset: 6pt,
          align: center + horizon,
          [*Column 3*],
        ),
      ),

      [Row 1 \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d \ d \ d \ d \
      d \ d \ d \ d \ d \ d \ d],
      [A],
      [B],

      [Row 2], [C], [D],
      [Row 3], [E], [F],
      [Row 4], [G], [H],
      [Row 5], [I], [J],
      [Row 6], [K], [L],
      [Row 7], [M], [N],
      [Row 8], [O], [P],
      [Row 9], [Q], [R],
      [Row 10], [S], [T],

      continuation-footer(
        align(right)[Table continued on next page]
      ),
    ),
    caption: [Basic breakable table],
  )
}