No history yet

Introduction to Shiny

From R Script to Web App

You've done the hard work in R. You've cleaned your data, run your analysis, and created a compelling plot. Now, how do you share it? You could send a static image, but what if you want your colleagues to explore the data themselves? What if they could adjust a filter, change a date range, or select a different variable to plot?

This is where Shiny comes in. Shiny is an R package that turns your analyses into interactive web applications. You don't need to know HTML, CSS, or JavaScript. If you know R, you can build a web app. It’s the perfect tool for creating dashboards, data explorers, and interactive reports for people who don't use R.

Shiny is a package from RStudio that can be used to build interactive web pages with R.

The Two Parts of a Shiny App

Every Shiny app has two key components: the User Interface (UI) and the Server. Think of them as the face and the brain of your application.

User Interface

noun

The front-end of the application; what the user sees and interacts with. It controls the layout and appearance.

The UI is built by defining an object, usually called ui. This object lays out all the elements the user will see: input controls like sliders and dropdown menus, and placeholders for outputs like plots and tables.

Server

noun

The back-end of the application; the computational engine that runs the R code in response to user input.

The Server is an R function, usually called server, that tells Shiny how to build and rebuild the R objects displayed in the UI. It's the part that actually does the work. It listens for changes from the UI, runs the necessary R code, and sends the results back to be displayed.

These two components are brought together in a single file, typically named app.R. The file defines the ui and server objects and then passes them to the shinyApp() function to create the app.

# Load the shiny library
library(shiny)

# Define the User Interface (UI)
ui <- fluidPage(
  # ... layout and inputs go here
)

# Define the Server logic
server <- function(input, output) {
  # ... R code to generate outputs goes here
}

# Run the application
shinyApp(ui = ui, server = server)

The Magic of Reactivity

The core concept that makes Shiny work is called reactivity. It's an action-reaction relationship between inputs and outputs. When a user changes an input in the UI, the server automatically re-runs the relevant R code and updates the corresponding output.

Think of it like a spreadsheet. When you change the value in one cell, any formula that depends on that cell recalculates instantly. Shiny apps work the same way.

This reactive programming model means you don't have to write complex code to watch for user actions. You simply declare the relationship between an input and an output, and Shiny handles the rest. For example, you might tell Shiny, "The histogram output$distPlot should be generated using the number of bins from input$bins." When the user moves the slider for the number of bins, Shiny knows it needs to redraw the histogram with the new value.

Reactivity is a core concept in Shiny that makes it easy to build interactive applications.

Getting Started

Before you can build an app, you need to install the Shiny package. If you haven't already, open R or RStudio and run this command in the console:

install.packages("shiny")

RStudio has excellent built-in support for Shiny. The easiest way to start a new project is to use its template.

Go to File > New File > Shiny Web App.... Give your application a name (like "my_first_app"), choose "Single File (app.R)", and click Create.

RStudio will generate a new app.R file with a complete, working example app that visualizes data from the Old Faithful geyser. This is the perfect place to start experimenting. Click the "Run App" button at the top of the editor to launch it. Play with the slider and see how the plot changes. Then, look through the code to see how the ui and server are defined and how the input slider is connected to the histogram output.

That's the basic foundation. By understanding the UI/Server structure and the concept of reactivity, you have the key building blocks to start creating your own interactive web applications with R.