Interactive Web Apps

with shiny Cheat Sheet

learn more at shiny.rstudio.com

Building an App

Tell server how to render outputs with R in

the server function. To do this:

App template
Begin writing a new app with this template. Preview
the app by running the code at the R command line.
library(shiny)
ui <- fluidPage()
server <- function(input, output){}
shinyApp(ui = ui, server = server)

ui - nested R functions that assemble an HTML user

interface for your app
server - a function with instructions on how to
build and rebuild the R objects displayed in the UI
shinyApp - combines ui and server into a
functioning app. Wrap with runApp() if calling from
a sourced script or inside a function.

Share your app

The easiest way to share your app
is to host it on shinyapps.io, a
cloud based service from RStudio

1. Create a free or professional account at

http://shinyapps.io

2. Click the Publish icon in the RStudio IDE

(>=0.99) or run:
rsconnect::deployApp("<path to directory>")
Build or purchase your own Shiny Server

"
!

at www.rstudio.com/products/shiny-server/

actionButton(inputId, label, icon, )

server <- function(input, output) {

output$hist <- renderPlot({
hist(rnorm(input$n))
})
}

3. Wrap code in a render*() function before

saving to output

actionLink(inputId, label, icon, )

shinyApp(ui = ui, server = server)

Save your template as app.R. Alternatively, split your template into two files named ui.R and server.R.
# ui.R

library(shiny)

Users can manipulate the UI, which will cause the

server to update the UIs displays (by running R code).

Access the current value of an input object with input

$<inputId>. Input values are reactive.

ui <- fluidPage(
numericInput(inputId = "n",
"Sample size", value = 25),
plotOutput(outputId = "hist")
)

Add outputs with *Output() functions

2. Refer to inputs with input$<id>

A Shiny app is a web page (UI) connected to a

computer running a live R session (Server)

Inputs - collect values from the user

library(shiny)

Add inputs to the UI with *Input() functions

1. Refer to outputs with output$<id>

Basics

- Complete the template by adding arguments to fluidPage() and a body to the server function.

ui <- fluidPage(
numericInput(inputId = "n",
"Sample size", value = 25),
plotOutput(outputId = "hist")
)

fluidPage(
numericInput(inputId = "n",
"Sample size", value = 25),
plotOutput(outputId = "hist")
)

server <- function(input, output) {

output$hist <- renderPlot({
hist(rnorm(input$n))
})
}

# server.R

shinyApp(ui = ui, server = server)

function(input, output) {
output$hist <- renderPlot({
hist(rnorm(input$n))
})
}

ui.R contains everything

you would save to ui.
server.R ends with the
function you would save
to server.
No need to call
shinyApp().

Save each app as a directory that contains an app.R file (or a server.R file and a ui.R file) plus optional extra files.

app-name

.r
$
$
$
$
$
#

The directory name is the name of the app

(optional) defines objects available to both
Launch apps with
ui.R and server.R
runApp(<path to
(optional) used in showcase mode
directory>)
(optional) data, scripts, etc.
(optional) directory of files to share with web
browsers (images, CSS, .js, etc.) Must be named "www"

app.R
global.R
DESCRIPTION
README
<other files>
www

checkboxGroupInput(inputId, label,
choices, selected, inline)
checkboxInput(inputId, label, value)
dateInput(inputId, label, value, min,
max, format, startview, weekstart,
language)
dateRangeInput(inputId, label, start,
end, min, max, format, startview,
weekstart, language, separator)
fileInput(inputId, label, multiple,
accept)
numericInput(inputId, label, value,
min, max, step)

Outputs - render*() and *Output() functions work together to add R output to the UI
DT::renderDataTable(expr,
options, callback, escape,
env, quoted)

works
with

dataTableOutput(outputId, icon, )

renderImage(expr, env, quoted, deleteFile)

imageOutput(outputId, width, height, click,

renderPlot(expr, width, height, res, , env,

plotOutput(outputId, width, height, click,

renderPrint(expr, env, quoted, func,

verbatimTextOutput(outputId)

quoted, func)
width)

dblclick, hover, hoverDelay, hoverDelayType,

brush, clickId, hoverId, inline)
dblclick, hover, hoverDelay, hoverDelayType,
brush, clickId, hoverId, inline)

passwordInput(inputId, label, value)

radioButtons(inputId, label, choices,
selected, inline)
selectInput(inputId, label, choices,
selected, multiple, selectize, width,
size) (also selectizeInput())

renderTable(expr,, env, quoted, func)

tableOutput(outputId)

sliderInput(inputId, label, min, max,

value, step, round, format, locale,
ticks, animate, width, sep, pre, post)

renderText(expr, env, quoted, func)

textOutput(outputId, container, inline)

submitButton(text, icon)

renderUI(expr, env, quoted, func)

RStudio is a trademark of RStudio, Inc. CC BY RStudio info@rstudio.com 844-448-1212 rstudio.com

uiOutput(outputId, inline, container, )

& htmlOutput(outputId, inline, container, )

More cheat sheets at http://www.rstudio.com/resources/cheatsheets/

(Prevents reactions across entire app)

textInput(inputId, label, value)

Learn more at shiny.rstudio.com/tutorial shiny 0.12.0 Updated: 6/15

Reactivity
Reactive values work together with reactive functions. Call a reactive value from within the arguments of one of
these functions to avoid the error Operation not allowed without an active reactive context.

Trigger
arbitrary code

observeEvent()

observe()

Modularize
reactions

run(this)

input$x

shinyApp(ui, server)

*Input() functions
reactiveValues()
Each input function
creates a reactive value
stored as input$<inputId>
reactiveValues() creates a
list of reactive values
whose values you can set.

Prevent reactions
library(shiny)
ui <- fluidPage(
textInput("a",""),
textOutput("b")
)

Render reactive output

CC 2015 RStudio, Inc.

render*() functions

library(shiny)
ui <- fluidPage(
textInput("a","")
)
server <function(input,output){
output$b <renderText({
input$a
})
}
shinyApp(ui, server)

library(shiny)

Runs a code block.

Returns a non-reactive
copy of the results.

ui <- fluidPage(
textInput("a",""),
actionButton("go", "")
)

shinyApp(ui, server)

shinyApp(ui, server)

Modularize reactions

server <function(input,output){
re <- reactive({
paste(input$a,input$b})
output$b <- renderText({
re()
})
}
shinyApp(ui, server)

reactive(x, env, quoted,

label, domain)

Creates a reactive expression

that
caches its value to reduce
computation
can be called by other code
notifies its dependencies
when it ha been invalidated
Call the expression with
function syntax, e.g. re()

Builds an object to
display. Will rerun code in
body to rebuild the object
whenever a reactive value
in the code changes.
Save the results to
output$<outputId>

observeEvent(eventExpr

isolate(expr)

server <function(input,output){
observeEvent(input$go,
print(input$a)
})
}

ui <- fluidPage(
textInput("a",""),
textInput("z", "")
)

(see front page)

Trigger arbitrary code

server <function(input,output){
output$b <renderText({
isolate({input$a})
})
}

library(shiny)

render*()

eventReactive()

(see front page)

server <function(input,output){
rv <- reactiveValues()
rv$number <- 5
}

Render
reactive output
Delay reactions

Create your own reactive values

Layouts

An apps UI is an HTML document. Use Shinys

functions to assemble this HTML with R.

Combine multiple elements into a "single element"

that has its own properties with a panel function, e.g.

fluidPage(
Returns
textInput("a","")
HTML
)
## <div class="container-fluid">
## <div class="form-group shiny-input-container">
##
<label for="a"></label>
##
<input id="a" type="text"
##
class="form-control" value=""/>
##
</div>
## </div>

output$y

Update

reactiveValues()

*Input()

ui <- fluidPage(
textInput("a","")
)

isolate()

expression()

Create your own

reactive values

library(shiny)

Prevent reactions

reactive()

UI

, handlerExpr, event.env,

event.quoted, handler.env,
handler.quoted, labe,
suspended, priority, domain,
autoDestroy, ignoreNULL)

Runs code in 2nd

argument when reactive
values in 1st argument
change. See observe() for
alternative.

Delay reactions
library(shiny)
ui <- fluidPage(
textInput("a",""),
actionButton("go", "")
)
server <function(input,output){
re <- eventReactive(
input$go,{input$a})
output$b <- renderText({
re()
})
}
shinyApp(ui, server)

RStudio is a trademark of RStudio, Inc. CC BY RStudio info@rstudio.com 844-448-1212 rstudio.com

eventReactive(eventExpr,
valueExpr, event.env,
event.quoted, value.env,
value.quoted, label,
domain, ignoreNULL)

Creates reactive
expression with code in
2nd argument that only
invalidates when reactive
values in 1st argument
change.

wellPanel(
dateInput("a", ""),
submitButton()
)

absolutePanel()
conditionalPanel()
fixedPanel()
headerPanel()

Add static HTML elements with tags, a list of

functions that parallel common HTML tags, e.g.
tags$a(). Unnamed arguments will be passed
into the tag; named arguments will become tag
attributes.
tags$a
tags$abbr
tags$address
tags$area
tags$article
tags$aside
tags$audio
tags$b
tags$base
tags$bdi
tags$bdo

tags$data
tags$datalist
tags$dd
tags$del
tags$details
tags$dfn
tags$div
tags$dl
tags$dt
tags$em
tags$embed

tags$h6
tags$head
tags$header
tags$hgroup
tags$hr
tags$HTML
tags$i
tags$iframe
tags$img
tags$input
tags$ins
tags$blockquote tags$eventsource tags$kbd
tags$keygen
tags$body
tags$fieldset
tags$br
tags$figcaption tags$label
tags$legend
tags$button
tags$figure
tags$li
tags$canvas
tags$footer
tags$link
tags$caption tags$form
tags$mark
tags$cite
tags$h1
tags$map
tags$code
tags$h2
tags$menu
tags$col
tags$h3
tags$meta
tags$colgroup tags$h4
tags$meter
tags$command tags$h5

tags$nav
tags$noscript
tags$object
tags$ol

tags$span
tags$strong
tags$style
tags$sub

tags$option
tags$output
tags$p
tags$param
tags$pre
tags$progress
tags$q
tags$ruby
tags$rp
tags$rt
tags$s
tags$samp
tags$script
tags$section
tags$select
tags$small
tags$source

tags$sup
tags$table
tags$tbody
tags$td
tags$textarea
tags$tfoot
tags$th
tags$thead
tags$time
tags$title
tags$tr
tags$track
tags$u
tags$ul
tags$var
tags$video
tags$wbr

fluidRow()

column

row

col

column

tags$optgroup tags$summary

flowLayout()
object object object
3
1
2
object
3

sidebarLayout()
side
panel

main
panel

ui <- fluidPage(
fluidRow(column(width = 4),
column(width = 2, oset = 3)),
fluidRow(column(width = 12))
)
ui <- fluidPage(
flowLayout( # object 1,
# object 2,
# object 3
)
)
ui <- fluidPage(
sidebarLayout(
sidebarPanel(),
mainPanel()
)
)

splitLayout()

ui <- fluidPage(
h1("Header 1"),
hr(),
br(),
p(strong("bold")),
p(em("italic")),
p(code("code")),
a(href="", "link"),
HTML("<p>Raw html</p>")
)

object object
1
2
verticalLayout()
object 1
object 2
object 3

To include a CSS file, use includeCSS(), or

1. Place the file in the www subdirectory
2. Link to it with

ui <- fluidPage(
splitLayout( # object 1,
# object 2
)
)
ui <- fluidPage(
verticalLayout( # object 1,
# object 2,
# object 3
)
)

Layer tabPanels on top of each other,

and navigate between them, with:

tags$head(tags$link(rel = "stylesheet",
type = "text/css", href = "<file name>"))

ui <- fluidPage( tabsetPanel(

tabPanel("tab 1", "contents"),
tabPanel("tab 2", "contents"),
tabPanel("tab 3", "contents")))

To include JavaScript, use includeScript() or

1. Place the file in the www subdirectory
2. Link to it with

ui <- fluidPage( navlistPanel(

tabPanel("tab 1", "contents"),
tabPanel("tab 2", "contents"),
tabPanel("tab 3", "contents")))

tags$head(tags$script(src = "<file name>"))

1. Place the file in the www subdirectory

2. Link to it with img(src="<file name>")

More cheat sheets at http://www.rstudio.com/resources/cheatsheets/

tabPanel()
tabsetPanel()
titlePanel()
wellPanel()

Organize panels and elements into a layout with a

layout function. Add elements as arguments of the
layout functions.

The most common tags have wrapper functions. You

do not need to prefix their names with tags$

IMAGES To include an image

inputPanel()
mainPanel()
navlistPanel()
sidebarPanel()

ui <- navbarPage(title = "Page",

tabPanel("tab 1", "contents"),
tabPanel("tab 2", "contents"),
tabPanel("tab 3", "contents"))

Learn more at shiny.rstudio.com/tutorial shiny 0.12.0 Updated: 6/15