# flexdashboard turns an R Markdown file into a resizing dashboard

> flexdashboard is an R Markdown output format that lays out related visualisations in rows and columns, resizes them to the browser, supports storyboard pages and can optionally be driven by Shiny. It suits analysts who want a small multi panel monitoring page without building a web application.

**rstudio/flexdashboard** — Easy interactive dashboards for R

- Repository: https://github.com/rstudio/flexdashboard
- Website: http://rstudio.github.io/flexdashboard/
- Stars: 848 · Forks: 297
- Language: JavaScript
- License: NOASSERTION
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/rstudio-flexdashboard

## An output format, not a dashboard library

The stated goal of flexdashboard is to make it easy to create interactive dashboards for R using R Markdown, and the mechanics follow from that. There is no separate object model and no runtime of its own. You write an R Markdown document and set its output format to `flexdashboard::flex_dashboard`, and the package takes over the rendering. From RStudio that means the New R Markdown dialog, and from the console you can draft a file with `rmarkdown::draft`. The package metadata shows the primary language is JavaScript, which fits: the layout and resizing behaviour lives in the browser side of the output, while the R side assembles the page. The repository carries a `DESCRIPTION` and `NAMESPACE` for the R package, `inst/` for the assets, `man/` for the documentation and `vignettes/` for the articles.

## What can sit on the page

The component list is what decides whether the format fits your report. The README says it supports a wide variety of components, and names them: htmlwidgets, base, lattice and grid graphics, tabular data, gauges and value boxes, and text annotations. That set is broad enough for the usual monitoring page, a chart next to a table next to a key number, with a text block explaining what the number means. The examples directory makes the same point concretely, with folders for a d3 heatmap, ggplotly, Shiny biclust, a Shiny crandash, dygraphs, highcharter, a storyboard, Shiny with ggplot2 brushing, rbokeh, metricsgraphics, Shiny kmeans, a leaflet waste map, further ggplotly examples, highcharter with pokemon, Shiny with eruptions, Shiny with diamonds, Shiny embedding, and Shiny neighbourhood diversity, plus a `deploy.R` file.

## Row and column layouts that reflow

The layout model is the core of the package and the reason it differs from a plain grid of plots. The README describes flexible and easy to specify row and column based layouts, and says components are intelligently re-sized to fill the browser and adapted for display on mobile devices. So the width of a panel is a layout decision rather than a fixed pixel value, and the same document is expected to work on a phone. There is a second layout mode for narrative use. Storyboard layouts present sequences of visualizations with related commentary, and the example folder `examples/07_storyboard/` shows what that looks like in practice. Storyboards are the reason this is more than a screen of charts: a sequence of pages where each page carries one chart and the text that explains it.

## Shiny and bslib are both optional

Two integrations are marked as optional in the README, and both change what the package can be. You can optionally use Shiny to drive visualizations dynamically, which turns a static document into something reactive, and the help text in the README asks you to add a `shiny` tag alongside the `flexdashboard` tag when you are using a Shiny runtime. You can also optionally use bslib to customize main colours, fonts and more, and the theming documentation is linked. The templates reflect this. There are two templates, `"flex_dashboard"` for the basic case and `"flex_dashboard_bslib"` for the themed one. A practical point follows from the example set: many of the shipped examples are Shiny based, so a static dashboard and a reactive one are both first class in the package, but the reactive ones bring a server with them.

## Installing from CRAN and drafting your first file

Installation from CRAN is a single call:

```r
install.packages("flexdashboard")
```

If you want the development version, the README points at the remotes package:

```r
remotes::install_github('rstudio/flexdashboard')
```

The first real use is creating the document. Inside RStudio that is the New R Markdown dialog, and outside RStudio you draft from the console, choosing one of the two templates, for example the themed one:

```r
rmarkdown::draft("dashboard.Rmd",
                 template = "flex_dashboard_bslib",
                 package = "flexdashboard")
```

The file that lands in your project is an R Markdown document with the `flex_dashboard` output format set, and from there you fill in the panels with the components you have. The two entry points differ in one visible way, since the bslib template is the example of theming, so the coloured headers, fonts and background come from that route rather than from the format itself.

## Where to get help, and which tags to use

The README names two help channels and is specific about how to use them. The RStudio community forum is described as a friendly place to ask questions about flexdashboard, where you should use the `flexdashboard` tag and add the `shiny` tag if you are using a Shiny runtime. Stack Overflow is called a great source of answers to common questions and a good place to get help once you have created a reproducible example, and again the tags matter, with `[r][flexdashboard]` for a plain question and the addition of `[shiny]` for a Shiny runtime. The project also ships a Contributor Code of Conduct, and contributing means agreeing to its terms. The `revdep/` directory in the repository is a reminder that a package used this widely gets tested against downstream packages.

## A custom licence and an uneven release line

GitHub classifies the licence of this repository as Other, meaning a custom licence the platform cannot map to a standard identifier, so the LICENSE file is the place to read the actual terms. The project is published on CRAN, which is the distribution channel most R users will actually use, and the release history shows a steady version number with uneven dates. The listed releases are 0.6.3 on 2026-01-28, 0.6.2 on 2023-08-12 and 0.6.1 on 2023-01-24, and the last push to the repository was on 2026-06-26. The repository is not archived, and the README itself is generated from `README.Rmd`, so the prose you read is knitted rather than written by hand. The documentation site is built with pkgdown, with `_pkgdown.yml` and a `pkgdown/` directory in the tree.

## Conclusion

Adopt flexdashboard when you need a single page of related visualisations that reflows on a phone, built from the plots and widgets you already use, because the format handles the row and column layout, the resizing and the storyboard pages for you. Do not adopt it when the dashboard needs a real application backend, a data pipeline or a large number of interactive filters, since the Shiny support is optional and the package is a rendering format rather than a framework. Verify first that the widget you plan to use is on the supported list, and remember the last push was on 2026-06-26 while the last CRAN release listed is 0.6.3 from 2026-01-28, so pin your version accordingly.

## FAQ

### How do I install flexdashboard?

Install it from CRAN with `install.packages("flexdashboard")`. For the development version the README suggests `remotes::install_github('rstudio/flexdashboard')`.

### How do I create a flexdashboard file outside RStudio?

Use `rmarkdown::draft` with a template name, either `flex_dashboard` for the basic case or `flex_dashboard_bslib` for the themed example, passing the `flexdashboard` package.

### What kinds of content can a flexdashboard page contain?

The README lists htmlwidgets, base, lattice and grid graphics, tabular data, gauges and value boxes, and text annotations.

### Is Shiny required to use flexdashboard?

No. Shiny is optional and can be used to drive visualizations dynamically. When you do use it, the README asks that you add the `shiny` tag alongside the `flexdashboard` tag on the community forum and Stack Overflow.

### What layouts does flexdashboard support?

Row and column based layouts whose components are re-sized to fill the browser and adapted for mobile devices, plus storyboard layouts for presenting sequences of visualizations with related commentary.

## Sources

- [Issues](https://github.com/rstudio/flexdashboard/issues)
- [Project website](http://rstudio.github.io/flexdashboard/)
- [README](https://github.com/rstudio/flexdashboard/blob/main/README.md)
- [Releases](https://github.com/rstudio/flexdashboard/releases)
- [rstudio/flexdashboard on GitHub](https://github.com/rstudio/flexdashboard)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rstudio-flexdashboard