25 rhino

Published

2026-10-16

TLDR

WARNING: rhino isn’t like the previous two frameworks we’ve covered in this section, because rhino doesn’t create an app-package:

rhino apps rely on renv and box for managing imported dependencies (instead of the DESCRIPTION and NAMESPACE files in an R package).
rhino requires node.js, an open-source JavaScript runtime environment.

This chapter briefly describes a version of sap built using the rhino framework. The branch in this chapter is slightly different than the previous golem and leprechaun frameworks, because rap is not an R package. If you’re developing in RStudio , instead of loading, documenting, and installing rap, we’re going to re-initialize the IDE by selecting Session > Terminate R…

When RStudio re-opens, we see the rap files and notice the Build pane has been removed:

To reiterate, the Build pane is deactivated because rhino applications aren’t R packages.¹

Launch the application in rap by opening the app.R file and clicking Run App (or by passing rhino::app() into the Console).

Launch app with the shinypak package:

launch('25_rhino')

Calling rhino::app() — Calling `rhino::app()`

Access the applications in this chapter

I’ve created the shinypak R package in an effort to make each section accessible and easy to follow. Install shinypak using pak (or remotes):

install.packages('pak')
pak::pak('mjfrigaard/shinypak')
library(shinypak)

List the apps in this chapter:

list_apps(regex = '^25')

Launch apps with launch()

launch(app = '25_rhino')

Download apps with get_app()

get_app(app = '25_rhino')

25.1 `rap` (a `rhino` app)

The files in rap are below:

├── .git
├── .github
│       └── workflows
│             └── rhino-test.yml
├── .gitignore
├── .lintr
├── .renvignore
├── .rhino
│       ├── .eslintrc.json
│       ├── .gitignore
│       ├── .stylelintrc.json
│       ├── babel.config.json
│       ├── node_modules
│       ├── package-lock.json
│       ├── package.json
│       ├── prettier.config.mjs
│       └── webpack.config.js
├── .Rhistory
├── .Rprofile
├── .rscignore
├── app
│   ├── js
│   │   └── index.js
│   ├── logic
│   │   ├── __init__.R
│   │   ├── data.R
│   │   └── plot.R
│   ├── main.R
│   ├── static
│   │   ├── css
│   │   ├── favicon.ico
│   │   └── js
│   ├── styles
│   │   └── main.scss
│   └── view
│       ├── __init__.R
│       ├── aes_inputs.R
│       ├── clicks.R
│       ├── display.R
│       ├── message.R
│       └── var_inputs.R
├── app.R
├── config.yml
├── dependencies.R
├── README.md
├── renv
│   ├── .gitignore
│   ├── activate.R
│   ├── library
│   │   └── macos
│   ├── settings.json
│   └── staging
├── renv.lock
├── rhino.yml
├── sap.Rproj
└── tests
    ├── cypress
    │   ├── .gitignore
    │   └── e2e
    ├── cypress.config.js
    ├── testthat
    │   ├── _snaps
    │   ├── setup-shinytest2.R
    │   ├── test-aes_inputs.R
    │   ├── test-data.R
    │   ├── test-display.R
    │   ├── test-main.R
    │   ├── test-plot.R
    │   ├── test-rap-feature-01.R
    │   ├── test-shinytest2.R
    │   └── test-var_inputs.R
    └── testthat.R

1: CI/CD via GitHub actions
2: Lintr (from lintr package)
3: renv ignore (works like .gitignore)
4: rhino app dependencies
5: Activates the renv package
6: renv library of packages in app project

As we can see, most of the standard R package folders and files are missing from rap, because rhino applications use the box package for importing dependencies and organizing code.²

25.2 `rhino` features

The rhino website explains the philosophy behind the application structure above, so I won’t repeat that information here. However, I highly recommend reading the available documentation on rhino and box before deciding to adopt this framework.³

25.3 `box` modules

A box module (not to be confused with a Shiny module) is a collection of .R scripts in a specified folder. The modules in a new rhino app are stored in the app/logic/ and app/view/ folders:⁴

app ├── js/ ├── logic/ ├── main.R ├── static/ ├── styles/ └── view/ 6 directories, 1 file

1. JavaScript code 2. Non-shiny code
3. Primary app file
4. Static .js or .css
5. App CSS files 6. Shiny modules and app code

25.3.1 Utility functions

In rap, I’ve placed the non-Shiny utility functions (i.e., the business logic) in app/logic:

app/logic ├── __init__.R ├── data.R └── plot.R 1 directory, 4 files

1. Load movies data
2. scatter_plot() utility function

25.3.2 Shiny modules

Our Shiny box modules are placed in app/view, and separated into inputs and display:

app/view ├── __init__.R ├── aes_inputs.R ├── display.R └── var_inputs.R 1 directory, 6 files

1. similar to the code from R/mod_aes_input.R
2. similar to the code from R/mod_scatter_display.R 3. similar to the code from R/mod_var_input.R

app/view/aes_inputs and app/view/var_inputs collect and return the reactive values from the UI. The app/view/display module includes the app/logic/data and app/logic/plot modules.

# app/view/display.R

# import data and plot modules
box::use(
  app / logic / data,
  app / logic / plot
)

25.4 `app/main.R`

The app/main.R file contains the primary UI and Server functions for the application. This file adds the shiny functions and the aes_inputs, var_inputs, and display modules from app/view:

# app/main.R

# shiny functions
box::use(
  shiny[
    NS, span, tags, icon, moduleServer
  ],
  # bslib functions
  bslib[
    page_fillable, layout_sidebar, sidebar, 
    card, card_header, card_body, bs_theme
  ]
)

# import modules ----
box::use(
  ## load inputs module
  app / view / var_inputs,
  app / view / aes_inputs,
  ## load display module 
  app / view / display
)

Note that we don’t need to import app/logic modules in app/main.R, because they’re imported in their respective app/view modules.

25.5 Tests

rhino apps have support for testing with testthat, shiny::testServer(), shinytest2, and Cypress.

└── tests ├── cypress │ └── e2e │ └── app.cy.js ├── cypress.config.js ├── testthat │ └── test-main.R └── testthat.R

1. Cypress test infrastructure
1. testthat test infrastructure

Below is the boilerplate test code in the tests/testthat/test-main.R file:

box::use(
  shiny[testServer], 
  testthat[...],
)

box::use(
  app/main[...],
)

test_that("main server works", {
  testServer(server, {
    expect_equal(output$message, "Hello!")
  })
})

1: box module importing test package functions
2: Using shiny::testServer() and testthat::test_that() functions in test.

I’ve included tests for the utility functions and modules in the 25_rhino branch, but I’ll cover testing with rhino elsewhere.⁵

25.6 `rhino` dependencies

In rhino apps, dependencies are managed by renv and the dependencies.R file. The renv package is designed to,

“create[s] and manage[s] project-local R libraries, save[s] the state of these libraries to a ‘lockfile’, and later restore[s] the library as required.” ⁶

The rhino::pkg_install() helper function updates both the dependencies.R file and renv library. Using dependencies.R, renv, and box modules removes the need to manage dependencies in a DESCRIPTION or NAMESPACE file.⁷

Recap

RECAP

rhino takes a novel and innovative approach to developing Shiny applications (and covering all the ways they differ from app-packages is beyond the scope of this book). Feel free to review the code in the 25_rhino branch for a better understanding of how the box modules are structured and used within the ui and server.

The rhino framework isn’t used as wildly golem,⁸ but it’s been gaining popularity (and has been used in a recent pilot FDA submission).

rhino CRAN downloads — `rhino` CRAN downloads

See a typo, error, or something missing?

Please open an issue on GitHub

I re-initialize the session on the 25_rhino branch so I’m not tempted to load, document, install, or test the code using the IDE.↩︎
Imported dependencies in rhino apps use box modules instead of the DESCRIPTION and NAMESPACE.↩︎
Be sure to read up on testing box modules and rhino applications with cypress and shinytest2.↩︎
rhino recommends placing non-Shiny code in the app/logic folder and keeping all Shiny modules and reactive code in app/view.↩︎
See the Shiny frameworks supplemental website for more information on testing your rhino app.↩︎
As described in renv’s DESCRIPTION file ↩︎
Be sure to read the renv configuration article for a better understanding on how it works with rhino apps.↩︎
Check for yourself on cran-downloads ↩︎

25.1 rap (a rhino app)

25.2 rhino features

25.3 box modules