Visual editor for R Shiny

Build R Shiny apps by drag and drop, and get clean `app.R` code

DropToApp is a Shiny UI designer for data scientists and R users. Lay out sidebars, cards, grids and tabs, add inputs and outputs, and watch the Shiny and bslib code write itself, ready to run with shiny::runApp().

Design the interface visually, with the R code updating side by side
Edit the code by hand and the design follows, or the other way round
Export standard Shiny and bslib code, with no lock-in

Create a free account See how it works

Free to use. Your designs stay in your browser.

The DropToApp editor: a component palette on the left, a Shiny app with a sidebar, value boxes and a histogram in the middle, and the generated app.R code below it — The editor: components on the left, your app in the middle, the generated R code underneath.

Everything you need to design a Shiny user interface

Building a Shiny UI by hand means nesting function calls and remembering argument names. DropToApp lets you see the layout while you build it, and still gives you code you'd be happy to write yourself.

Drag-and-drop layouts

Pages with a sidebar, cards, tabsets and value boxes, built from modern bslib components rather than legacy fluidRow() grids.

Grids of rows and columns

Add a column or row one cell at a time, split cells, and nest grids inside grids. Column widths stay balanced automatically.

Visual and code editing, in sync

Type in app.R and the canvas updates as you go. Change the design and the code is regenerated. Errors show the line and column.

Inputs, outputs and server code

Sliders, selects, buttons, plots, tables and more, each with its server code: renderPlot(), renderTable() and observeEvent() blocks are written for you.

Open existing apps

Import an app.R and keep working visually. Code DropToApp has no editor for, such as DT tables or helper functions, is kept exactly as written.

Themes and responsive preview

Preview Bootswatch themes and check the layout at desktop, tablet and phone widths before you run a single line of R.

From idea to a running Shiny app in three steps

No setup and nothing to install: DropToApp runs in your browser.

Drag in your components

Start from an example or a blank page, then drop layouts, inputs and outputs where you want them.
Fine-tune the details

Set IDs, labels, choices and widths in the properties panel, or edit the R code directly. Both stay in sync.
Export and run

Download app.R and run it with shiny::runApp(), locally or on Shiny Server, Posit Connect or shinyapps.io.

Supported Shiny and bslib components

DropToApp writes the same functions you'd use by hand, so the code is easy to read, extend and maintain.

Layout

page_sidebar(), page_fillable(), page_fluid()
sidebar() and card() with headers
layout_columns() grids of rows and columns
navset_card_tab() with nav_panel() tabs
value_box() for key numbers

Inputs

sliderInput(), numericInput()
textInput(), textAreaInput()
selectInput(), radioButtons()
checkboxInput(), checkboxGroupInput()
dateInput(), actionButton()

Outputs and content

plotOutput() with renderPlot()
tableOutput() with renderTable()
textOutput() and verbatimTextOutput()
Headings, paragraphs and dividers
R code blocks for any other UI, like DT::DTOutput()

Made for people who build with R

Whether you ship dashboards every week or are building your first Shiny app.

Data scientists

Prototype a dashboard layout in minutes, then spend your time on the analysis instead of on nested UI code.

Analysts and researchers

Turn an R analysis into an interactive app your colleagues can use, without becoming a web developer first.

Teachers and students

See how every part of the interface maps to Shiny code. It's a hands-on way to learn how Shiny apps are built.

Frequently asked questions

What is DropToApp?

DropToApp is a visual editor for R Shiny user interfaces. You drag layouts, inputs and outputs onto a canvas, adjust them in a properties panel, and DropToApp writes a complete, readable app.R file using Shiny and bslib as you work.

Do I need to know R to use it?

Not to design the interface: layouts, inputs and outputs are all point-and-click. To connect your own data and logic you write R in each output's server code field, and seeing the generated code next to the design is also a practical way to learn how Shiny apps are put together.

Does the exported app depend on DropToApp?

No. The export is plain Shiny and bslib code with no DropToApp package or runtime. Install the two packages with install.packages(c("shiny", "bslib")) and run the app with shiny::runApp(), locally, on Shiny Server, Posit Connect or shinyapps.io.

Can I open an existing Shiny app?

Yes. Open an app.R whose UI uses page_sidebar(), page_fillable() or page_fluid() and DropToApp rebuilds the design from it. Anything it has no visual editor for is kept as an R code block, and code outside the UI (data loading, reactives, helper functions) is preserved as written.

Can I edit the code by hand?

Yes. The code view is a full editor: type in app.R and the canvas updates as you go, or change the design and the code is regenerated. Syntax errors are pointed out with the line and column, and the design waits until the code is valid again.

Which Shiny components are supported?

Page layouts with a sidebar, cards, grids of columns and rows, tabsets, value boxes, sliders, numeric and text inputs, text areas, select inputs, radio buttons, checkboxes, date inputs, action buttons, plot, table, text and console outputs, headings and paragraphs, plus R code blocks for anything else.

Where are my designs stored?

In your own browser. Designs are autosaved locally and never uploaded to our servers; you can save a design file or export app.R at any time. Your account is only used to sign you in.

Is DropToApp free?

Yes, creating an account and using the editor is free.

Start building your Shiny app

Create a free account and have your first layout on screen in a minute.

Create a free account