Open-source project
rstudio/shiny avatar
rstudio/shiny

The npm package ships declarations and a licence, and the R support policy covers the latest release plus four previous minors

Easy interactive web applications with R

5,705 stars1,893 forksRNOASSERTION

At a glance

What is it?
Shiny turns R code into a reactive web application without asking you to write HTML, CSS or JavaScript. The readme is a well-organised summary, and the files around it are where the current state shows: a types-only npm package, three licence files, an agent skill inside the installed package, and an R support policy covering the latest release plus the previous four minor versions.
Who is it for?
Shiny remains the shortest path from an R script to a web application that other people can use, and its reactive model is the part worth understanding rather than the widget library, because the claim that it does less work per input change is what makes the difference at scale. Three things to check before you commit a team to it.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly R, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • rstudio/shiny5,705 ★ · +10
Star history
Repository2026-09-242026-11-15
rstudio/shiny5.7k5.7k

10 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The npm package ships declarations and a licence file, and nothing else

There are two distributions here and the smaller one is easy to misread. The npm package is scoped to the publisher's organisation, its file list contains exactly two kinds of entry, a licence file and a directory of TypeScript declaration files, and both of its entry points for a bundler and for a browser are empty strings. In other words it is a types-only package: its job is to let an editor resolve Shiny's client-side types, not to run anything. Its declared version carries an alpha suffix with a large build number, which is how a development version of the same codebase is kept distinguishable from the released one on the language's own package repository, where the recent releases are numbered in the ordinary way. The package also requires a recent Node and package manager, ships its own dependencies as type definitions for the front-end libraries the interface is built on, and pins several of them to exact versions, and there is a separate readme in the tree for the npm audience alone.

The version numbers on the two package managers differ by a suffix

The published releases are 1.12.1, then 1.13.0, then 1.14.0, spread across the second half of 2025 and the first half of 2026. The manifest for the npm package reads 1.14.0 with an alpha marker and a build number, which is the conventional way of saying this is the working tree after the last release rather than the release itself. So the two versions you will encounter are related but not identical, and the failure mode is benign: someone installing from the npm registry expecting to get the application is installing type declarations. The readme is not where that confusion gets resolved, because it documents the language package and never mentions the second one. The other package-level detail worth knowing is the licence: the page states that the package as a whole is MIT and points at a file, and the tree carries three licence-related entries, which suggests some part of what ships carries terms of its own.

The support policy's worked example lists five versions while saying four

The last section states the policy plainly: the latest release of the language is supported, along with the previous four minor releases. That is a sensible and generous policy, and it is the kind of sentence that gets written once and left. The example that follows it is consistent with that: it assumes the current release is 4.3 and lists 4.3 plus the four previous minor releases, 4.2, 4.1, 4.0 and 3.6, crossing from the 4.x line back to 3.6. The section is also the only place in the readme where a version boundary is documented at all, so a reader pinning an interpreter has nothing else to go on.

Reactivity is pitched as less work rather than as different syntax

The feature list leads with the reactive programming model, and the argument for it is quantitative before it is aesthetic. The model turns existing code into a live application whose outputs react to new input, and the stated advantage over event-based programming is that it does the minimum amount of work when an input changes, with a second claim that it is easier for a person to reason about when the underlying structure follows a model-view-controller shape. That is a fair characterisation of what a dependency graph buys you. The widgets are described as prebuilt and customizable, and the default appearance comes from a well-known front-end framework, which the page then gives you two documented ways out of: a companion package for restyling, or direct bindings that let you write the markup yourself.

Duplication, state and reproduction are the three features that are not visual

Three of the bullets have nothing to do with how the application looks, and they are the ones that decide whether the framework survives a second application. The first is a modules system, described plainly as a framework for reducing code duplication and complexity, which is the standard answer to the objection that every application ends up with its own badly organised helper functions. The second is the ability to bookmark the application's state, which turns a session into a link, with a companion project named as the way to generate the code that reproduces a given output rather than just the link. The third is the extension ecosystem, listed as packages for custom widgets, for input validation and for unit testing, which is the honest measure of the framework's maturity: the things people build for it are the things a mature framework needs and a young one lacks. Each of those three links out to a separate project, so the page is an index rather than a description.

Performance tooling is a feature, and the two learning paths have different freshness

Performance appears in the feature list rather than in a separate section, and it is specified as tooling for improving and monitoring it: native support for asynchronous programming, caching, and load testing, each linked to its own article or project. That is an unusual thing to find in a feature list and a fair signal that the framework has had to grow up, because a synchronous request-response model becomes the bottleneck long before the interface does. The learning section offers three routes and, unusually, ranks two of them against each other. There is a gallery of user-submitted examples, a book, and a tutorial. The page says the book is currently more up to date with modern features while the tutorial takes a deeper and more visual dive into the fundamentals. That sentence is the most useful thing in the documentation section, because it tells a reader choosing between them what the trade-off actually is.

The package ships an agent skill, and a helper installs it into your project

The newest bullet is about coding agents, and it is worth reading as a design decision rather than as a feature. The skill file lives inside the installed package, at a path the page gives as a call to the standard file-resolution function with the package name, so it travels with the library rather than with a repository clone. Agents using a particular helper discover it automatically once the package is attached, To copy it into a project for tools that read skill files from disk, one call does it:

r
btw::btw_skill_install_package("shiny")

The page names one such tool explicitly and generalises to the category. Two other details in the tree point the same way. There is a separate readme for the npm audience and a licence note file, both of which exist because the package is consumed by more than one ecosystem, and there is a .madgerc configuration file at the root.

Editorial conclusion

Shiny remains the shortest path from an R script to a web application that other people can use, and its reactive model is the part worth understanding rather than the widget library, because the claim that it does less work per input change is what makes the difference at scale. Three things to check before you commit a team to it. Which R versions you actually have, since the policy is the current release plus four previous minors. Which documentation path you follow, because the page itself says one is fresher and the other is deeper. And what the performance tooling will cost you, since the answer is not in the readme and the extension packages around widgets, validation and testing are where the real integration work sits.

Frequently asked questions

how to install shiny package in r

One line from the language's package repository: install.packages("shiny"). The page then gives the first command to run, which loads the library and launches a prepackaged example application with its source code included, and a second that lists the other examples.

Which R versions does shiny support?

The latest release of R plus the previous four minor releases. The worked example on the page assumes the latest is 4.3 and lists 4.3, 4.2, 4.1, 4.0 and 3.6.

What does the shiny Agent Skill do?

It teaches coding agents to write idiomatic Shiny for R applications, and it ships inside the installed package rather than in a clone. Agents using one particular helper discover it automatically once the package is attached, and a single function call copies it into a project for tools that read skill files from a directory.

What does shiny provide for performance?

Tools for improving and monitoring it are part of the feature list: native support for asynchronous programming, caching, and load testing. The reactive model itself is pitched on the same ground, as doing less work when an input changes than event-based programming would.

Is the shiny npm package the framework itself?

No. The npm package is a types-only distribution: its file list holds a licence file and TypeScript declaration files, and its bundler and browser entry points are both empty strings. Its version also carries an alpha suffix with a build number, while the released versions on the language's package repository are numbered in the ordinary way.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. rstudio/shiny on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/rstudio-shiny.svg)](https://hysenlabs.com/projects/rstudio-shiny)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/rstudio-shiny.svg)](https://hysenlabs.com/projects/rstudio-shiny)

Was this useful?