What is Rhino?
Rhino is an R package designed to help you build high quality,
enterprise-grade Shiny applications at speed. It allows you to create
Shiny apps “The Appsilon Way” - like a fullstack software engineer:
apply best software engineering practices, modularize your code, test it
well, make UI beautiful and think about adoption from the very
beginning.
Rhino is an opinionated framework with a focus on best practices and
development tools. It started as a series internal projects at Appsilon
aiming to:
- Save time and avoid repetitive tasks: include all best practices we
care about from the very beginning of a project.
- Unify applications’ architecture: provide sensible defaults so that
we don’t reinvent the wheel.
- Automate and codify our existing practices: pass knowledge in the
form of code instead of documents and manuals.
Over the past few years, we have been building internal tools to
address these issues and help us easily structure projects in a fast
way. It has since evolved into an R package that we are now excited to
share with the Shiny community.
Please keep in mind that this project is in the early stages. We
wanted to get something out to the R community and look forward to
continuing development with feedback from users. This is just the
beginning.
Why Rhino?
Because Rhino helps you build Shiny apps faster, while making them
more reliable and easier to maintain. It bundles in a coherent way a set
of tools and practices that are beneficial for most Shiny applications,
especially in enterprise.
You may want to use Rhino if:
- You need a nested files structure that will handle a bigger
application.
- You want to follow a complete set of solutions built on industry
experience, avoid spending time “reinventing the wheel”.
- You’d like to have a scalable, modularized application with clear
code organization and neat separation of responsibilities. Rhino can
serve as a guide to understanding these concepts (box, Shiny modules,
view / logic separation).
- You want to save time and avoid repetitive tasks. Rhino allows you
to quickly start your Shiny project with a set of preconfigured
development tools (linters, CI, Cypress, logging, Sass and JS
building)
- You are building an application for production use in enterprise -
you need to make sure it’s highly maintainable and reliable in the long
term. Most Shiny applications can be converted to a Rhino project in
less than 2 hours.
Similar projects
Rhino is not the first project of its kind aimed at helping the Shiny
community to enhance the structure of their applications. We believe
that each of these has value, and it is up to the developer to decide
what is best for them in their project.
How Rhino is different from …?
-
golem: Rhino apps are not R packages. Rhino puts
more emphasis on development tools, clean configuration and minimal
boilerplate and tries to provide default solutions for typical problems
and questions in these areas.
-
leprechaun: Leprechaun works by scaffolding Shiny
apps, without adding dependencies. Rhino minimizes generated code and
aims to provide a complete foundation for building Shiny apps ready for
deployment in enterprise, so that you can focus on application’s logic
and user experience.
-
devtools: devtools streamlines packages
development. Rhino is a complete framework for building Shiny apps.
Rhino features are interdependent (e.g. coverage and unit tests) and
cannot be used without making the app into basic Rhino structure.
-
usethis: usethis adds independent code snippets you
ask it to. Rhino is a complete framework for building Shiny apps. Your
app is designed to call Rhino functions instead of having them insert
code into your project.