The UI

The UI (“User Interface”) is used to specify what “elements” should be included in the R Shiny graphical interface. This produces HTML which is used to display your element in the browser. You can try printing the ui object (print(ui)), and you will see that it is simply HTML.

There are different types of page layouts - fluidPage() is a layout based on the Bootstrap web library (LINK) and allows designing your web page in rows, within which you can specify columns.

The server

The server part is what will happen in the background. If deploying as a web page, this part will be run on the computer hosting the code, while the UI will be run on the user’s computer. This part will generate data and figures which subsequently can be displayed in the interface.

The function(input, output) {} is the server function. It always takes the UI input and output elements as arguments. The input will contain all your input elements, such as the slider. The output will contain the output points, such as where the plots should be rendered. Right now, the body of it is empty. Soon we will add more code here!

A note on reactivity

In the default example, we saw an interactive histogram. The UI contains information about that we want a panel layout, one input element and one output point for the plot. The server will recalculate the plot based on the input it receives (in this case - from a single input slider) and sends it to the UI to be displayed.

You can see it in its very minimal form in the geyser dataset. There is one input with the ID “bins”. This input is used to calculate the plot which subsequently is sent to the output “distPlot”.

Basic reactivity

This is a lazy kind of evaluation - the server code will only run when it needs to. The term for this kind of programming is ‘reactive programming’. More on this later.

Exercises

1. Take a look at the code for the default {shiny} application. Identify the “bins” and the “distPlot” ID in the UI part. Next, look into the server part. How are they used in this part?
2. Make some adjustment to the UI. Try changing the title and the “Number of bins” label.
3. Try adding a descriptive text above the plot using the p("text") element (within the main panel in the UI part).
4. See if you can add a custom header to the histogram, allowing a user to change the header interactively. Use the ?hist to see how to change its header. You can add a text input to the interface using the code textInput(<id>, <label>), exchanging <id> and <label> with your own values.

Retrieving the data

This tutorial uses a dataset from Gapminder - an organization promoting a factful view of the world. The dataset contains life expectancies in different countries since 1800. Gapminder has many useful datasets exploring different aspects of the world. Feel free to take a look and use whichever tickles your interest.

Other great pages for datasets:

• Kaggle, has many great datasets but might require some more preparsingpreparsing before visualizing
• If you want to visualize something related to Coronavirus, here is a source data home page

(Optional) Parsing the data from scratch

Note: If you don’t want to do this part - jump straight to the next section and load the data preparsed. It is here as a reference if you want to parse your own data.

I have prepared a comma-separated Gapminder dataset on life expectancy from the year 1800. If you have your own dataset, exchange the file path for that one instead and adjust the code accordingly.

First, we load the comma-delimited data using the read_csv command. Next, we use the head command to inspect the first few rows.

data_wide <- read_csv("gapminder_life_expectancy_years.csv")

## Parsed with column specification:
## cols(
##   .default = col_double(),
##   country = col_character()
## )

## See spec(...) for full column specifications.

head(data_wide)

## # A tibble: 6 x 302
##   country `1800` `1801` `1802` `1803` `1804` `1805` `1806` `1807` `1808` `1809`
##   <chr>    <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>
## 1 Afghan…   28.2   28.2   28.2   28.2   28.2   28.2   28.1   28.1   28.1   28.1
## 2 Albania   35.4   35.4   35.4   35.4   35.4   35.4   35.4   35.4   35.4   35.4
## 3 Algeria   28.8   28.8   28.8   28.8   28.8   28.8   28.8   28.8   28.8   28.8
## 4 Andorra   NA     NA     NA     NA     NA     NA     NA     NA     NA     NA  
## 5 Angola    27     27     27     27     27     27     27     27     27     27  
## 6 Antigu…   33.5   33.5   33.5   33.5   33.5   33.5   33.5   33.5   33.5   33.5
## # … with 291 more variables: `1810` <dbl>, `1811` <dbl>, `1812` <dbl>,
## #   `1813` <dbl>, `1814` <dbl>, `1815` <dbl>, `1816` <dbl>, `1817` <dbl>,
## #   `1818` <dbl>, `1819` <dbl>, `1820` <dbl>, `1821` <dbl>, `1822` <dbl>,
## #   `1823` <dbl>, `1824` <dbl>, `1825` <dbl>, `1826` <dbl>, `1827` <dbl>,
## #   `1828` <dbl>, `1829` <dbl>, `1830` <dbl>, `1831` <dbl>, `1832` <dbl>,
## #   `1833` <dbl>, `1834` <dbl>, `1835` <dbl>, `1836` <dbl>, `1837` <dbl>,
## #   `1838` <dbl>, `1839` <dbl>, `1840` <dbl>, `1841` <dbl>, `1842` <dbl>,
## #   `1843` <dbl>, `1844` <dbl>, `1845` <dbl>, `1846` <dbl>, `1847` <dbl>,
## #   `1848` <dbl>, `1849` <dbl>, `1850` <dbl>, `1851` <dbl>, `1852` <dbl>,
## #   `1853` <dbl>, `1854` <dbl>, `1855` <dbl>, `1856` <dbl>, `1857` <dbl>,
## #   `1858` <dbl>, `1859` <dbl>, `1860` <dbl>, `1861` <dbl>, `1862` <dbl>,
## #   `1863` <dbl>, `1864` <dbl>, `1865` <dbl>, `1866` <dbl>, `1867` <dbl>,
## #   `1868` <dbl>, `1869` <dbl>, `1870` <dbl>, `1871` <dbl>, `1872` <dbl>,
## #   `1873` <dbl>, `1874` <dbl>, `1875` <dbl>, `1876` <dbl>, `1877` <dbl>,
## #   `1878` <dbl>, `1879` <dbl>, `1880` <dbl>, `1881` <dbl>, `1882` <dbl>,
## #   `1883` <dbl>, `1884` <dbl>, `1885` <dbl>, `1886` <dbl>, `1887` <dbl>,
## #   `1888` <dbl>, `1889` <dbl>, `1890` <dbl>, `1891` <dbl>, `1892` <dbl>,
## #   `1893` <dbl>, `1894` <dbl>, `1895` <dbl>, `1896` <dbl>, `1897` <dbl>,
## #   `1898` <dbl>, `1899` <dbl>, `1900` <dbl>, `1901` <dbl>, `1902` <dbl>,
## #   `1903` <dbl>, `1904` <dbl>, `1905` <dbl>, `1906` <dbl>, `1907` <dbl>,
## #   `1908` <dbl>, `1909` <dbl>, …

This data is in wide-format, meaning that we have one column per year. In the plotting library {ggplot2} (part of {tidyverse}) the data is expected to be in long format with one column showing the year and one column containing all the life expectancies.

For instance, the following matrix is in wide format - the measured data is spread over multiple columns.

country   1900   1950   2000
Sweden    60     77     80
Denmark   65     79     82

The same data is illustrated in the long format below. Now we have one column containing all measurements and one extra column specifying from which year the measurement was taken. This is harder to read, but easier for a computer program to manage.

country  year  life_expectancy
Sweden   1900  60
Sweden   1950  77
Sweden   2000  80
Denmark  1900  65
Denmark  1950  79
Denmark  2000  82

The transformation from wide to long format can be done using the command pivot_longer (part of the {tidyr} package, which is part of the {tidyverse}). Make sure to inspect the data with head to see what you are working with.

data_long <- data_wide %>% 
# The -1 means that we pivot all columns except the first to one column
    pivot_longer(-1, names_to = "year", values_to="life_expectancy") %>%
    mutate(year=as.numeric(year))

# Slicing out the first column headers
head(data_long)

## # A tibble: 6 x 3
##   country      year life_expectancy
##   <chr>       <dbl>           <dbl>
## 1 Afghanistan  1800            28.2
## 2 Afghanistan  1801            28.2
## 3 Afghanistan  1802            28.2
## 4 Afghanistan  1803            28.2
## 5 Afghanistan  1804            28.2
## 6 Afghanistan  1805            28.2

Loading the data preparsed

If you skipped the previous section - load the preparsedpreparsed data directly. This will load a three-column dataset specifying the country, measurement year and estimated life expectancy for that country and year.

Load the comma-delimited file using the read_csv command and inspect the first few lines with head.

data_long <- read_csv("gapminder_life_expectancy_years_parsed.csv")

## Parsed with column specification:
## cols(
##   country = col_character(),
##   year = col_double(),
##   life_expectancy = col_double()
## )

head(data_long)

## # A tibble: 6 x 3
##   country      year life_expectancy
##   <chr>       <dbl>           <dbl>
## 1 Afghanistan  1800            28.2
## 2 Afghanistan  1801            28.2
## 3 Afghanistan  1802            28.2
## 4 Afghanistan  1803            28.2
## 5 Afghanistan  1804            28.2
## 6 Afghanistan  1805            28.2

Now we are all set!

A minimal application

We will step by step build a complete R Shiny application for the dataset we previously prepared. If successful, you will have enough knowledge at the end to start building your own Shiny applications.

You can run the code directly from this notebook by executing the chunks one by one or create an empty .R file (for instance named app.R) where you step by step, build the application. At this point, you will only get a blank page.

# library(shiny) <- Uncomment if running in a separate .R file, already loaded in the notebook
ui <- fluidPage()
server <- function(input, output) {}  
shinyApp(ui=ui, server=server)

Preparing the UI

Here we will add some different headers and input elements, as well as an output point where we later will show two figures.

# Uncomment if running in a separate .R file
# library(shiny)
ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(),
        mainPanel()
    )
)
server <- function(input, output) {}
shinyApp(ui=ui, server=server)

print(ui)

# Uncomment if running in a separate .R file
# library(shiny)
ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", min=1800, max=2030, step=1, value = c(1800, 2030)),
            selectInput(inputId="countries", label="Countries", choices = c("Sweden", "Denmark", "Norway", "Iceland", "Finland"), selected="Sweden")
        ),
        mainPanel(
            plotOutput(outputId="year_range_plot")
        )
    )
)
server <- function(input, output) {}
shinyApp(ui=ui, server=server)

Setting up the server

Up until now our server function have been completely empty. Now we will add code for generating a figure which subsequently will be sent to the UI and shown to the user.

data_long_sweden <- data_long %>% filter(country == "Sweden")
head(data_long_sweden)

## # A tibble: 6 x 3
##   country  year life_expectancy
##   <chr>   <dbl>           <dbl>
## 1 Sweden   1800            32.2
## 2 Sweden   1801            36.9
## 3 Sweden   1802            40.2
## 4 Sweden   1803            40.3
## 5 Sweden   1804            39.7
## 6 Sweden   1805            41

ggplot(data_long_sweden, aes(x=year, y=life_expectancy)) + 
    geom_line() +
    ggtitle("Swedish life expectancy")

data_long_sweden_range <- data_long %>% 
    filter(country == "Sweden") %>%
    filter(year >= 1900 & year <= 2000)
head(data_long_sweden_range)

## # A tibble: 6 x 3
##   country  year life_expectancy
##   <chr>   <dbl>           <dbl>
## 1 Sweden   1900            52.3
## 2 Sweden   1901            52.9
## 3 Sweden   1902            54.7
## 4 Sweden   1903            55.1
## 5 Sweden   1904            55.4
## 6 Sweden   1905            54.5

ggplot(data_long_sweden_range, aes(x=year, y=life_expectancy)) + 
    geom_line() +
    ggtitle("Swedish life expectancy")

# Uncomment if running in a separate .R file
# library(shiny)
# library(tidyverse)
# data_long <- read_csv("data/gapminder_life_expectancy_years_parsed.csv")

ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", value=c(1800, 2030), min=1800, max=2030, step=1),
            selectInput(inputId="countries", label="Countries", choices = c("Sweden", "Denmark", "Norway", "Iceland", "Finland"), selected="Sweden")
        ),
        mainPanel(
            plotOutput(outputId="year_range_plot")
        )
    )
)
server <- function(input, output) {
    
    output$year_range_plot <- renderPlot({
        
        data_long_sweden_range <- data_long %>% 
            filter(country == "Sweden") %>%
            filter(year >= 1900 & year <= 2020)
        
        ggplot(data_long_sweden_range, aes(x=year, y=life_expectancy)) + 
            geom_line() +
            ggtitle("Swedish life expectancy")
    })
    
}
shinyApp(ui=ui, server=server)

# Uncomment if running in a separate .R file
# library(shiny)
# library(tidyverse)
# data_long <- read_csv("data/gapminder_life_expectancy_years_parsed.csv")

all_countries <- unique(data_long$country)

ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", value=c(1800, 2030), min=1800, max=2030, step=10),
            selectInput(inputId="countries", label="Countries", choices = all_countries, multiple = TRUE, selected=c("Sweden", "Denmark", "Norway", "Iceland", "Finland"))
        ),
        mainPanel(
            plotOutput(outputId="year_range_plot")
        )
    )
)
server <- function(input, output) {
    
    output$year_range_plot <- renderPlot({
        
        data_long_filtered <- data_long %>% 
            filter(country %in% input$countries) %>%
            filter(year >= input$year_range[1] & year <= input$year_range[2])
        
        ggplot(data_long_filtered, aes(x=year, y=life_expectancy, color=country)) + 
            geom_line() +
            ggtitle("Life expectancies") +
            xlab("Year") +
            ylab("Life expectancy (years)")
    })
}
shinyApp(ui=ui, server=server)

Showing the data using multiple plots

One of the powerful things with RShiny is how easy it is to extend the interface to accommodate multiple figures showing different aspects of the same data.

Here, we produce a boxplot for the same dataset.

First, let’s try out the plot separately. We use code very similar to previously, but we exchange the geom_line with a geom_boxplot.

data_long_countries_range <- data_long %>% 
    filter(country %in% c("Sweden", "Denmark", "Norway", "Finland", "Iceland")) %>%
    filter(year >= 1920 & year <= 2020)
head(data_long_countries_range)

## # A tibble: 6 x 3
##   country  year life_expectancy
##   <chr>   <dbl>           <dbl>
## 1 Denmark  1920            57.5
## 2 Denmark  1921            61.7
## 3 Denmark  1922            60.6
## 4 Denmark  1923            61.1
## 5 Denmark  1924            61.1
## 6 Denmark  1925            61.9

ggplot(data_long_countries_range, aes(x=year, y=life_expectancy, color=country)) + 
    geom_boxplot() +
    ggtitle("Nordic countries life expectancy 1900 - 2020")

It seems like the better years are relatively similar, but there have been some tougher years in Finland and Iceland during the last 100 years.

Now we are ready to link this into the server part.

# Uncomment if running in a separate .R file
# library(shiny)
# library(tidyverse)
# data_long <- read_csv("data/gapminder_life_expectancy_years_parsed.csv")

all_countries <- unique(data_long$country)

ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", value=c(1800, 2030), min=1800, max=2030, step=10),
            selectInput(inputId="countries", label="Countries", choices = all_countries, multiple = TRUE, selected=c("Sweden", "Denmark", "Norway", "Iceland", "Finland"))
        ),
        mainPanel(
            plotOutput(outputId="year_range_plot"),
            plotOutput(outputId="year_range_boxplot")
        )
    )
)
server <- function(input, output) {
    
    output$year_range_plot <- renderPlot({
        
        data_long_filtered <- data_long %>% 
            filter(country %in% input$countries) %>%
            filter(year >= input$year_range[1] & year <= input$year_range[2])
        
        ggplot(data_long_filtered, aes(x=year, y=life_expectancy, color=country)) + 
            geom_line() +
            ggtitle("Life expectancies") +
            xlab("Year") +
            ylab("Life expectancy (years)")
    })
    
    output$year_range_boxplot <- renderPlot({
        data_long_filtered <- data_long %>% 
            filter(country %in% input$countries) %>%
            filter(year >= input$year_range[1] & year <= input$year_range[2])
        
        ggplot(data_long_filtered, aes(x=year, y=life_expectancy, color=country)) + 
            geom_boxplot() +
            ggtitle("Life expectancies, boxplot")
    })
    
}
shinyApp(ui=ui, server=server)

Great! One ugly part here though is that we needed to duplicate the parsing part of the dataset (converting data_long into data_long_filtered). This is something we want to avoid as this kind of coding over time will make our code less maintainable and less readable. The way to do this in R Shiny is by using a reactive variable (here named data_long_filtered).

Dual plot reactivity

We use the reactive keyword and put in an expression which here is dependent on the reactive input variables input$countries and input$year_range. This expression will be rerun every time any of these input variables change, which in turn will trigger the plots to rerender (which now both depend on this reactive element). Note that when you use this one, you need to call it with parenthesizes similar to how you use a function (i.e. data_long_filtered()).

# Uncomment if running in a separate .R file
# library(shiny)
# library(tidyverse)
# data_long <- read_csv("data/gapminder_life_expectancy_years_parsed.csv")

all_countries <- unique(data_long$country)

ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", value=c(1800, 2030), min=1800, max=2030, step=10),
            selectInput(inputId="countries", label="Countries", choices = all_countries, multiple = TRUE, selected=c("Sweden", "Denmark", "Norway", "Iceland", "Finland"))
        ),
        mainPanel(
            plotOutput(outputId="year_range_plot"),
            plotOutput(outputId="year_range_boxplot")
        )
    )
)
server <- function(input, output) {
    
    data_long_filtered <- reactive({
        data_long %>% 
            filter(country %in% input$countries) %>%
            filter(year >= input$year_range[1] & year <= input$year_range[2])
    })
    
    output$year_range_plot <- renderPlot({
        
        ggplot(data_long_filtered(), aes(x=year, y=life_expectancy, color=country)) +
            geom_line() +
            ggtitle("Life expectancies") +
            xlab("Year") +
            ylab("Life expectancy (years)")
    })
    
    output$year_range_boxplot <- renderPlot({
        ggplot(data_long_filtered(), aes(x=year, y=life_expectancy, color=country)) + 
            geom_boxplot() +
            ggtitle("Life expectancies, boxplot")
    })
    
}
shinyApp(ui=ui, server=server)

Exercises

• Let the user customize the plot titles separately by adding two textInput UI fields. Make sure to have useful default values.
• Add a third output point and display the data using some other ggplot geom. You could, for instance, display it using geom_density or geom_point.
• (Advanced) If you are familiar with statistics - calculate the ANOVA across the different countries for the selected datasets and indicate the resulting p-value in the plot title.

Showing interactive tables using DT

We might want to show the displayed raw data directly. There is a built-in way of displaying tables, but using {DT} it looks much more attractive. The output point is called DTOutput, and for rendering, we use the command DT::renderDataTable.

The reactive table obtained from data_long_filtered can be rendered directly, but it is often easier for humans to read in wide format. For this, we can use the {tidyr} (part of Tidyverse) command pivot_wider where we specify which column contains what will become column headers, and what column contains the values.

# library(shiny) <- Uncomment if running in a separate .R file
# library(tidyverse)
# library(DT)
# data_long <- read_csv("data/gapminder_life_expectancy_years_parsed.csv")

all_countries <- unique(data_long$country)

ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", value=c(1800, 2030), min=1800, max=2030, step=10),
            selectInput(inputId="countries", label="Countries", choices = all_countries, multiple = TRUE, selected=c("Sweden", "Denmark", "Norway", "Iceland", "Finland"))
        ),
        mainPanel(
            plotOutput(outputId="year_range_plot"),
            plotOutput(outputId="year_range_boxplot"),
            DT::dataTableOutput(outputId="table_display")
        )
    )
)
server <- function(input, output) {
    
    data_long_filtered <- reactive({
        data_long %>% 
            filter(country %in% input$countries) %>%
            filter(year >= input$year_range[1] & year <= input$year_range[2])
    })
    
    output$year_range_plot <- renderPlot({
        
        ggplot(data_long_filtered(), aes(x=year, y=life_expectancy, color=country)) +
            geom_line()
    })
    
    output$year_range_boxplot <- renderPlot({
        ggplot(data_long_filtered(), aes(x=country, y=life_expectancy, color=country, text=year)) + 
            geom_boxplot()
    })
        
    output$table_display <- DT::renderDataTable({
        data_long_filtered() %>% pivot_wider(names_from="year", values_from="life_expectancy")
    })
}
shinyApp(ui=ui, server=server)

Further interactivity with Plotly

Plotly is a library giving us the chance to make the plots directly interactive - meaning that we can hover and click elements directly, and use a range of tools such as zooming. It is possible to use it to do more advanced tasks such as executing code when clicking or marking certain parts of the graph, but that is beyond the scope of this tutorial.

To use Plotly, you need to load (and install) the library {plotly}. It has its own custom syntax for defining plots and contains a range of plots (it can also be used in Python). It is also compatible with ggplot-plots using the ggplotly function.

To incorporate Plotly, we need to update our plotOutput, and renderPlot points to plotlyOutput and renderPlotly. Next, we convert our ggplot outputs by sending the plot object into the ggplotly function. Then we are ready to go!

Some things do not work out of the box here, unfortunately. The x- and y-labels get cut off. They can be assigned the Plotly-way but adding the code %>% layout(xaxis=list(title="Year"), yaxis=list(title="Life expectancy (years)")) after the ggplotly command.

# Uncomment these lines if running in a separate .R file
# library(shiny)
# library(tidyverse)
# library(plotly)
# library(DT)
# data_long <- read_csv("data/gapminder_life_expectancy_years_parsed.csv")

all_countries <- unique(data_long$country)

ui <- fluidPage(
    titlePanel("Life Expectancy Shiny App"),
    sidebarLayout(
        sidebarPanel(
            sliderInput(inputId="year_range", label="Year range", value=c(1800, 2030), min=1800, max=2030, step=10),
            selectInput(inputId="countries", label="Countries", choices = all_countries, multiple = TRUE, selected=c("Sweden", "Denmark", "Norway", "Iceland", "Finland"))
        ),
        mainPanel(
            plotlyOutput(outputId="year_range_plot"),
            plotlyOutput(outputId="year_range_boxplot"),
            DTOutput(outputId="table_display")
        )
    )
)
server <- function(input, output) {
    
    data_long_filtered <- reactive({
        data_long %>% 
            filter(country %in% input$countries) %>%
            filter(year >= input$year_range[1] & year <= input$year_range[2])
    })
    
    output$year_range_plot <- renderPlotly({
        
        plt <- ggplot(data_long_filtered(), aes(x=year, y=life_expectancy, color=country)) +
            geom_line()
        ggplotly(plt) %>% layout(xaxis=list(title="Year"), yaxis=list(title="Life expectancy (years)"))
    })
    
    output$year_range_boxplot <- renderPlotly({
        plt <- ggplot(data_long_filtered(), aes(x=country, y=life_expectancy, fill=country, text=year)) + 
            geom_boxplot()
        ggplotly(plt, tooltip="text") %>% layout(xaxis=list(title="Country"), yaxis=list(title="Life expectancy (years)"))
    })
    
    output$table_display <- DT::renderDataTable({
        data_long_filtered() %>% pivot_wider(names_from="year", values_from="life_expectancy")
    })
}
shinyApp(ui=ui, server=server)

Deploying the app to shinyapps.io

You already know how to run your app locally. If you have access to a server, you can deploy it yourself using Shiny server (https://rstudio.com/products/shiny/shiny-server/). This requires some Linux-knowledge, but is comparably much easier than deploying a server yourself from scratch!

An even easier way (if you are fine with deploying your app publicly) is to deploy it to shinyapps.io. This can be done in a matter of a minute. You get up to 5 applications and 25 active hours for free.

All instructions below are outlined in more details at https://docs.rstudio.com/shinyapps.io/getting-started.html.

First:

1. Go to shinyapps.io and create a new account - Note that your account name will be used as part of the URL for your apps
2. Install the R-package {rsconnect}

Next, you need to retrieve tokens used to connect. Go to the Account/Tokens page on shinyapps.io and click “Show”. This will give you a line of code calling the following function - replacing TOKEN and SECRET with your token and secret.

rsconnect::setAccountInfo(name='accountname', token="<TOKEN>", secret="<SECRET>"

Now you are all set to deploy your app! Either by clicking the publish button in the top right (the blue symbol looking like an eye) or by executing the command:

rsconnect::deployApp()

Have some patience while it prepares it. At the end, it will give you an URL. Now you can show off your app to friends and family!