A Comparative Review of the RKWard GUI for R

by Robert A. Muenchen, updated July 9, 2026

Introduction

RKWard is a free and open-source Graphical User Interface for the R software, one that supports beginners looking to point-and-click their way through analyses, as well as advanced programmers. You can think of it as a blend of the menus and dialog boxes that R Commander offers combined with the programming support that RStudio provides. RKWard is available on Windows, Mac, and Linux. However, the Mac version has problems, as described by the RKWard Mac webpage: “The 0.8.0 version of RKWard on Mac is known to crash during startup, occasionally, for reasons still under investigation. Please just try again. Once successfully started, RKWard should work, reliably.”

This review is one of a series which aims to help non-programmers choose the Graphical User Interface (GUI) that is best for them. However, I do include a cursory overview of how RKWard helps you work with code. In most sections, I’ll begin with a brief description of the topic’s functionality and how GUIs differ in implementing it. Then I’ll cover how RKWard does it.

I have joined the BlueSky Statistics development team and have written the BlueSky User Guide (online here), but you can trust this series of reviews, as I describe here. All my comments below are easily verifiable. There is no perfect user interface for everyone; each GUI for R has features that appeal to different people.

Figure 1. RKWard’s main control screen containing an open data editor window (big one), an open dialog box (right) and its output window (lower left).

Terminology

There are various definitions of user interface types, so here’s how I’ll be using the following terms. Reviewing R GUIs keeps me quite busy, so I don’t have time also to review all the IDEs, though my favorite is RStudio.

GUI = Graphical User Interface, specifically using menus and dialog boxes to avoid having to type programming code. I do not include any assistance for programming in this definition. So GUI users are people who prefer using a GUI to perform their analyses. They often don’t have the time required to become good programmers.

IDE = Integrated Development Environment which helps programmers write code. I do not include point-and-click style menus and dialog boxes when using this term. IDE users are people who prefer to write R code to perform their analyses.

Installation

The various user interfaces available for R differ quite a lot in how they’re installed. Some, such as jamovi or BlueSky Statistics, install in a single step. Others install in multiple steps, such as R Commander and Deducer. Advanced computer users often don’t appreciate how lost beginners can become while attempting even a single-step installation. I work at the University of Tennessee, and our HelpDesk is flooded with such calls at the beginning of each semester!

Installing RKWard on Windows is done in a single step since its installation file contains both R and RKWard. Linux binaries do not contain a matching copy of R, but the package manager will obtain R (unless already installed). On Mac, the user is responsible for installing R manually. Regardless of their operating system, RKWard users never need to learn how to start R, then execute the install.packages function, and then load a library. 

The RKWard installer obtains the appropriate version of R, simplifying the installation and ensuring complete compatibility. However, if you already had a copy of R installed, depending on its version, you could end up with a second copy.

RKWard minimizes the size of its download by waiting to install some R packages until you actually try to use them for the first time. Then it prompts you, offering default settings that will get the package you need.

Plug-ins

When choosing a GUI, one of the most fundamental questions is: what can it do for you? What the initial software installation of each GUI gets you is covered in the Graphics, Analysis, and Modeling section of this series of articles. Regardless of what comes built-in, it’s good to know how active the development community is. They contribute “plug-ins” that add new menus and dialog boxes to the GUI. This level of activity ranges from very low (RKWard, BlueSky, Deducer) through moderate (jamovi) to very active (R Commander).

Currently, all plug-ins are included with the initial installation.  You can see them using the menu selection Settings> Configure Packages> Manage RKWard Plugins. There are only brief descriptions of what they do, but once installed, you can access the help files with a single click.

RKWard add-on modules are part of standard R packages and are distributed on CRAN. Their package descriptions include a field labeled “enhances: rkward”. You can sort packages by that field in RKWard’s package installation dialog, which displays them with the RKWard icon.

Startup

Some user interfaces for R, such as jamovi and BlueSky Statistics, start by double-clicking on a single icon, which is great for people who prefer not to write code. Others, such as R commander, have you start R, then load a package from your library, then call a function. That’s not good for GUI users, but for people looking to learn the R language, it helps them on their way.

RKWard is started directly as a stand-alone application, not from within R. The next time you start it up, it offers to load your last open workspace & it knows its location.

Data Editor

A data editor is a fundamental feature in data analysis software. It puts you in touch with your data and lets you get a feel for it, if only in a rough way. A data editor is such a simple concept that you might think there would be hardly any differences in how they work in different GUIs. While there are technical differences, to a beginner, what matters the most are the differences in simplicity. Some GUIs, including jamovi and Bluesky, let you create only what R calls a data frame. They use more common terminology and call it a dataset: you create one, you save one, later you open one, then you use one. Others, such as the R Commander, trade this simplicity for the full R language perspective: a data set is stored in a workspace. So the process goes: you create a data set, you save a workspace, you open a workspace, and then choose a data set from within it.

RKWard’s spreadsheet-style data editor is very easy to use. It puts its metadata – variable name, label, type, format, and levels – at the top of each variable (Figure 2). This makes it seem quite natural that you start at the top of the spreadsheet and work your way down until you’re entering the data values. Under “Type” you can double-click to reveal a dropdown menu that shows 1:Numeric, 2:Factor, 3:String, and 4:Logical. You can either click on one of those choices or type its number to make the selection.

Figure 2. RKWard’s Data Editor showing metadata (top third), and regular data.

Double-clicking “Levels” opens a dialog that offers values of a factor, such as 1 or 2, and prompts you to enter each label, such as Male or Female. When finished, you can then continue with data entry, typing numbers, and having RKWard convert their numbers to the labels. That makes data entry quick and accurate.

The tab key takes you to the next cell. It also adds a new variable when you reach the end of the defined variables. That’s handy if it’s what you want to do, but it’s also easy to create a new variable by accident. If that happens, right-click on the variable name and choose “delete.”

The Home and End keys take you to the beginning or end of an observation. So to begin entering a new observation, you press Home, then cursor down (or vice versa). I would prefer that the Enter key be used in place of that two-key sequence, but Excel users will probably like it as is.

To save your dataset, choose Workspace> Save Workspace. Recall that to start creating a dataset, you use File> New> Dataset. Since there’s no matching File> Save> Dataset, the beginner is left to make the mental leap that a workspace is the thing that needs saving!

When opening an existing data set, most programs will show you the data in spreadsheet form, but RKWard doesn’t. The file opens into a new tabbed window, but that window does not pop to the front, making you wonder if you succeeded in opening the file or not. Another way you’ll know it opened is that its name appears in the Workspace window in the upper left of the main control window.

Data Import / Export

RKward offers a limited selection of data import & export formats:

  1. Delimited Values (.csv, .tsv)
  2. Plain text files (.txt)
  3. Excel (old and new xls file types)
  4. SPSS (.sav)
  5. Standard R workspace files (.RData)

Data Management

It’s often said that 80% of data analysis time is spent preparing the data. Variables need to be transformed, recoded, or created; missing values need to be handled; datasets need to be stacked or merged, aggregated, transposed, or reshaped (e.g. from wide to long and back). An essential aspect of data management is the ability to transform many variables simultaneously. For example, social scientists need to recode many survey items; biologists need to take the logarithms of many variables. Doing such tasks one variable at a time is tedious. Some GUIs, such as R Commander and BlueSky Statistics, handle nearly all of these challenges. Others, such as JASP, offer just a handful of data management functions.

RKWard’s collection data mangement features is one of the most powerful of any of the R GUIs. Its Data menu offers the following choices:

  1. ANOVA > Prepare within-subject data
  2. Class and Structure > Batch Column Conversion
  3. Class and Structure > Coerce Data Structure
  4. Class and Structure > Coerce Vector Type
  5. Class and Structure > Manipulate Lists > Create or Append List
  6. Class and Structure > Manipulate Lists > Extract List Elements
  7. Combine Data Tables (dplyr) > Combine by Binding
  8. Combine Data Tables (dplyr) > Filtering Joins
  9. Combine Data Tables (dplyr) > Mutating Joins
  10. Combine Data Tables (dplyr) > Set Operations
  11. Data Cleaning (janitor) > Clean Data
  12. Data Cleaning (janitor) > Frequency Tables
  13. Data Cleaning (janitor) > Inspect Cases
  14. Data Cleaning (janitor) > Manage Duplicates
  15. Data Wrangling > Batch Recode
  16. Data Wrangling > Batch Transform
  17. Data Wrangling > Create Composite Score
  18. Data Wrangling > Create Dummy Variables (fastDummies)
  19. Date and Time (lubridate) > Apply Stamp Function
  20. Date and Time (lubridate) > Calculations > Advanced Extractions
  21. Date and Time (lubridate) > Calculations > Align Dates
  22. Date and Time (lubridate) > Calculations > Check Overlaps
  23. Date and Time (lubridate) > Calculations > Decimal Conversion
  24. Date and Time (lubridate) > Calculations > Shift Dates
  25. Date and Time (lubridate) > Convert to R Date-Time
  26. Date and Time (lubridate) > Create Stamp Function
  27. Date and Time (lubridate) > Format Dates as Text
  28. Date and Time (lubridate) > Get Date Component
  29. Date and Time (lubridate) > Parse Date-Times with Lubridate
  30. Date and Time (lubridate) > Round Date-Times
  31. Date and Time (lubridate) > Set Component in Date
  32. Date and Time (lubridate) > Time Spans > Create Durations
  33. Date and Time (lubridate) > Time Spans > Create Intervals
  34. Date and Time (lubridate) > Time Spans > Create Periods
  35. Date and Time (lubridate) > Time Zones
  36. Effect sizes > Calculate effect sizes
  37. Effect sizes > Calculate multigroup effect sizes
  38. Effect sizes > Calculate repeated measures effect sizes
  39. Factor Tools (forcats) > Drop Unused Levels
  40. Factor Tools (forcats) > Manually Relevel
  41. Factor Tools (forcats) > Reorder by Other Variable
  42. Factor Tools (forcats) > Reorder by Property
  43. Factor Tools (forcats) > Shift or Shuffle Levels
  44. Generate Random Data
  45. Google Sheets (googlesheets4) > Advanced Operations
  46. Google Sheets (googlesheets4) > Authenticate
  47. Google Sheets (googlesheets4) > Create New Sheet
  48. Google Sheets (googlesheets4) > Find Sheet by Name
  49. Google Sheets (googlesheets4) > Get Metadata from URL
  50. Google Sheets (googlesheets4) > Read googlesheets
  51. Google Sheets (googlesheets4) > Write Data to Sheet
  52. Lookup / Vlookup
  53. Multiple-choice > Prepare test data
  54. Names and Labels > Clean Names and Labels
  55. Names and Labels > Dictionary Search
  56. Names and Labels > Import DDI Metadata
  57. Names and Labels > Pattern Replacement
  58. Names and Labels > Sequential Renaming
  59. Names and Labels > Value Labels (Levels) > Catalog Assignment
  60. Names and Labels > Value Labels (Levels) > Import Catalog
  61. Official Statistics > Download US Census Data
  62. Official Statistics > IPUMS > Adjust grouped weights
  63. Official Statistics > IPUMS > Download IPUMS CPS
  64. Pattern Replacement (sub/gsub)
  65. Pivot Reshape > Pivot Longer
  66. Pivot Reshape > Pivot Wider
  67. Recode categorical data
  68. Reports (flextable) > Create Table
  69. Reports (flextable) > Export Table
  70. Sort data
  71. Split Data (cSplit)
  72. String Manipulations (stringr) > Detect and Locate Matches
  73. String Manipulations (stringr) > Extract from Strings
  74. String Manipulations (stringr) > Manage String Length
  75. String Manipulations (stringr) > Mutate Strings
  76. String Manipulations (stringr) > Split Strings
  77. Subset data.frame
  78. Tidy Data (tidyr) > Expand or Complete
  79. Tidy Data (tidyr) > Handle Missing Values
  80. Tidy Data (tidyr) > Manage Row Names
  81. Tidy Data (tidyr) > Nest and Unnest
  82. Tidy Data (tidyr) > Unite Columns
  83. Transpose Dataframe

Menus & Dialog Boxes

The goal of pointing & clicking your way through an analysis is to save time by recognizing menu settings rather than the more difficult task of recalling programming commands. Some GUIs, such as jamovi, make this easy by sticking to menu standards and using simple dialog boxes; others, such as the R Commander, use sequences of dialog boxes and/or non-standard menus that are unique to it and hence require more learning.

Figure 1 shows a typical RKWard session. The main control panel is the big window in the back. It has tabbed windows for each open data set and output set. RKWard makes it very easy to right-click on the tabs to detach any tabbed window. That would make it quite easy to compare two data sets side-by-side or to make full use of multiple displays.

At the top of the control panel, you’ll find the usual “File, Edit…Help” menus. Immediately below that is a toolbar containing shortcut icons. These provide a commonly used subset of the main menus, and the icons that appear there change slightly depending on your actions. The icons include: Open, Create, Save, Save Script…. The Save icon does drop down a menu, offering to save your workspace (i.e., your dataset) or your script. The “Save Script” icon is handy for saving your most recent changes to the same filename with a single click. The usual CTRL-S shortcut does the same thing.

Running plots or analyses are done as usual by making menu selections. Dialog boxes appear, and you select variables, then click an arrow icon to move them into the empty role boxes (also shown in Fig 1, right). The shortcut CTRL-click allows you to select a set of variables one at a time, as usual. Shift-click lets you select contiguous sets of variables, but a bug in the development tool RKward uses (Qt) doesn’t always show you they’re selected until you wave your mouse pointer across the selected variables. Unlike many other R GUIs, you can’t drag and drop the variables into their various roles.

When you’ve made your dialog box choices, you click “Submit” to run the step. If you want to see the R code that each dialog generates, click the “Code Preview” box in the bottom right corner of each dialog, and it will appear in the bottom of the dialog. While the code is displayed, any dialog changes you make will immediately be reflected in the code, which is very helpful when you’re learning to program. The reverse is not true since you cannot make changes to the code there. You would have to copy it and paste it into the program editor.

Most other GUIs maintain their dialog box settings within a work session, so if you wanted to do a variation of the previous step, you would simply choose it from the menus again. If you try that in RKWard, you’ll see your last round of settings have been cleared out. They are saved in the output file though. Each set of results in the output window contains a “Run again” link at the bottom of its section. Clicking that link will restore the dialog, complete with all the settings you used for that section of output.

While most dialog boxes are controlled by selecting variables from data frames, some require other types of data objects. For example, the factor analysis plug-in requires data stored in a correlation matrix. However, the correlation matrix dialog box doesn’t allow for saving the matrix, so you’d have to know how to do that using R code.

When exiting RKWard, it asks if you want to save your workspace and code (if you’ve entered any). It will automatically save your output and the dialog boxes required to make it in the file rk_out.html. This is loaded automatically in future sessions and maintains its “Run Again” capability. To save that to a different location, you can use “Workspace> Save workspace” or, on the lower set of menus, “Save> Save workspace.”

Documentation & Training

The user documentation for RKWard is located on the project’s web site. YouTube.com also offers many training videos that show how to use RKWard.

Help

R GUIs provide simple task-by-task dialog boxes, which generate much more complex code. Sometimes, that code consists of custom functions that control R’s standard ones. So, for a particular task, there is the potential for you to need help at three levels of complexity. Nearly all R GUIs provide that level of help when needed. The notable exception is the R Commander, which lacks help on the dialog boxes.

RKWard provides help files at all three levels. Each dialog box has a help button that provides a summary description, how to use the dialog box, all the GUI settings, what related functions are used, any dependencies involved, and an “About” section that provides the function’s version and its authors. Each help page also links to R’s built-in help on any functions used.

When you click on Help in a dialog, the help appears in RKWard’s main window. That comes to the front, which may cover up the dialog itself. That window contains Back, and Forward buttons, which you might think would get you back to the dialog box. So, it’s best to move the dialog to a space on your screen to allow you to read the help and see the dialog simultaneously.

The Help menu offers a search capability, but it searches only general R functions, not RKWard’s GUI-based capabilities.

Graphics

The various GUIs available for R handle graphics in several ways. Some, such as BlueSky and Deducer focus on using the popular ggplot2 package. Others, such as the R Commander, build in support for base graphics, lattice graphics, and use plug-ins for ggplot2. Still others, such as jamovi, use their own functions so they can tie them closely to the type of analysis being done.

GUIs also differ greatly in how they control the style of the graphs they generate. Ideally, you would set the style, and all graphs would follow it. That’s how jamovi works, but then jamovi is limited in the type of graphs that it does. BlueSky uses ggplot2 graphics almost exclusively, and its dialogs offer to apply “themes” from the ggthemes package.

RKWard plots are done by R’s built-in plots except for some specialty plots such as Pareto. None of them are done using lattice or ggplot2. As a result, plots of group comparisons are fairly limited.

While RKWard doesn’t let you set the style of graphics in advance, its use of R’s built-in plot functions guarantees that at least they all share one style. RKWard can save its plots to PNG, JPEG, or SVG files.

Plots in RKWard can initially be confusing, as its default highlighted variable entry box is used for pre-summarized data. For GUI users, that’s a pretty odd concept; they seldom have such data. When you enter standard un-summarized data into that field, a blank plot window results with “Error in -0.01 * height : non-numeric argument to binary operator”. Checking the “Tabulate data before plotting” box gets things working in a more standard GUI way.

RKWard’s graphics features include:

  1. Bar chart
  2. Box plot
  3. Cluster Analysis > Determine number of clusters
  4. Density plot
  5. Dot plot
  6. ECDF Plot (Empirical Cumulative Distribution Function)
  7. Factor Analysis > Correlation plot
  8. General plot
  9. Histogram
  10. Interaction plot
  11. Interactive BI > 1. Data Model Linker
  12. Interactive BI > 2. Interactive Slicer
  13. Interactive BI > 3. Interactive Chart
  14. Interactive BI > 4. Interactive Table
  15. Interactive BI > 5. Summary Card (KPI)
  16. Interactive BI > 6. Dashboard Assembler
  17. Interactive BI > 7. Export to HTML
  18. Maps > Download > Download Country Map Object
  19. Maps > Download > Download Global/Regional Maps
  20. Maps > Download > Download Municipalities
  21. Maps > Export Spatial Data
  22. Maps > Get Map Names
  23. Maps > Import Spatial Data
  24. Maps > Merge Maps
  25. Maps > Plot Categorical Map
  26. Maps > Plot Continuous Map
  27. Maps > Plot tidycensus map
  28. Maps > Recode Map Regions
  29. Maps > Transform Map Projection
  30. Network Graphs > Export Networks
  31. Network Graphs > Matrix to Network
  32. Network Graphs > Ranks to Network
  33. Open Street Map > Get Open Street Map Data
  34. Open Street Map > Plot Cartographr Map
  35. Pareto chart
  36. Pie chart
  37. Scatter plot
  38. Stem and leaf plot
  39. Storytelling with Data > Focus Bar Chart
  40. Storytelling with Data > Focus Line Chart
  41. Storytelling with Data > Focus Scatter Plot
  42. Storytelling with Data > Slopegraph
  43. Storytelling with Data > Dumbbell Plot
  44. Storytelling with Data > Big Number Summary
  45. Word Cloud > Create word cloud

Modeling

The way models are created and managed has a tremendous impact on both the flexibility and complexity of a user interface. The various R GUIs differ quite a lot in this regard. The simplest, and least flexible approach, is taken by jamovi which tries to do everything you might need in a single dialog box. R Commander goes the opposite direction, saving models and then offering users 25 menu selections to apply to those models. See their respective reviews on how well they succeed with each approach.

RKWard takes the simplest approach to modeling, by creating the model and offering you most of what you might want from that model in a single dialog box. The regression and ANOVA dialog boxes allow you to save models. However, there are no other menu entries devoted to model management manipulation. That struck me as a surprising choice since, in many other ways, RKWard uses the most powerful approach (e.g., code generation, programming support, object viewer, etc.).

Analysis Methods

All of the R GUIs offer a decent set of statistical analysis methods. Some also offer machine learning methods. Since this topic is so complex, I’ll simply list the methods RKWard comes with.

The first one on the Analysis menu is “Basic Statistics.” Oddly enough, by default, it doesn’t run any! I thought something had malfunctioned as I’ve never seen a stat package that didn’t offer a standard set of statistics at this stage. Just to test how it handles obvious errors, I included a factor and asked for the mean, sd, etc. This yielded the standard R messages, which beginners would find perplexing. It would have been more helpful to prevent the request by not displaying factors in that dialog box or by blocking their selection.

It turned out that the cause of my problem was that the Recode procedure had converted a numeric variable to a factor as it recoded it! The help file pointed out that there is a “Data type after recoding” setting that is set to “factor” by default. Here is a list of RKWard’s standard set of analyses, which is particularly strong in psychometrics. The Teaching menu contains duplicates of other menus, which I do not include below.

  1. Aiken’s Coefficients > Aiken’s H (Homogeneity)
  2. Aiken’s Coefficients > Aiken’s V (Content Validity)
  3. ANOVA for between effects
  4. ANOVA for mixed effects
  5. ANOVA within, or repeated measures, effects
  6. Basic Statistics
  7. Classical test theory > Comparing Cronbach’s alphas
  8. Cluster Analysis > hierarchical
  9. Cluster Analysis > K-means
  10. Cluster Analysis > model-based
  11. Cohen’s Kappa
  12. Correlation > Comparing correlations
  13. Correlation > Matrix Plot
  14. Correlation > Matrix > Kendall’s tau
  15. Correlation > Matrix > Pearson’s product-moment correlation
  16. Correlation > Matrix > Polychoric correlation
  17. Correlation > Matrix > Polyserial correlation
  18. Correlation > Matrix > Spearman’s rho
  19. Crosstabs N to 1
  20. Crosstabs N to N
  21. Custom Tables (expss) > Custom Table Builder
  22. Data Documentation Codebook > Generate Codebook
  23. Descriptive Statistics
  24. Design of Experiments (DoE) > Analyze Design
  25. Design of Experiments (DoE) > Fractional Factorial
  26. Design of Experiments (DoE) > Full Factorial Design
  27. Distributions: 63 dialogs cover most univariate distributions
  28. Factor analysis > Factor analysis
  29. Factor analysis > Measure of sampling adequacy (Kaiser-Meyer-Olkin)
  30. Factor analysis > Number of factors > Parallel analysis (Horn)
  31. Factor analysis > Number of factors > Scree plot
  32. Factor analysis > Number of factors > Very simple structure/Min ave. partial
  33. gt Summaries > Summary Table (gtsummary)
  34. gt Summaries > Survey Summary Table (gtsummary)
  35. Industrial Stats > Reliability > Life Data Analysis
  36. Industrial Stats > Reliability > Warranty Prediction
  37. Industrial Stats > Six Sigma > Attribute Agreement
  38. Industrial Stats > Six Sigma > Gage R and R
  39. Industrial Stats > Six Sigma > Process Capability
  40. Item Response Theory > Cronbach’s alpha
  41. Item Response Theory > Dichotomous Data > Birnbaum 3 param model
  42. Item Response Theory > Dichotomous Data > Linear logistic test model
  43. Item Response Theory > Dichotomous Data > Rasch model fit
  44. Item Response Theory > Dichotomous Data > Two parameter logistic model fit
  45. Item Response Theory > Polytomous Data > Generalized partial credit model fit
  46. Item Response Theory > Polytomous Data > Graded response model fit
  47. Item Response Theory > Polytomous Data > Linear partial credit model fit
  48. Item Response Theory > Polytomous Data > Linear rating scale model fit
  49. Item Response Theory > Polytomous Data > Partial credit model fit
  50. Item Response Theory > Polytomous Data > Rating scale model fit
  51. Item Response Theory > Tests > Andersen LR Plot (RSM, PCM)
  52. Item Response Theory > Tests > Goodness of Fit (Rasch)
  53. Item Response Theory > Tests > Item-fit statistics (Rasch, LTM, 3PM)
  54. Item Response Theory > Tests > Person-fit statistics (Rasch, LTM, 3PM)
  55. Item Response Theory > Tests > Unidimensionality check (Rasch, LTM, 3PM)
  56. Item Response Theory > Tests > Wald test (RSM, PCM)
  57. Means > t-Tests > Pairwise t-Test
  58. Means > t-Tests > t-Test
  59. Moments > Anscombe-Glynn Test of Kurtosis
  60. Moments > Bonett-Seier Test of Geary’s Kurtosis
  61. Moments > D’Agostino Test of Skewness
  62. Moments > Moment
  63. Moments > Skewness and Kurtosis
  64. MPT > MPTinR2
  65. Multidimensional scaling
  66. Multiple choice > Evaluate test
  67. Multiple Response (expss) > Define Variable Set
  68. Multiple Response (expss) > Multiple Response Crosstabs
  69. Multiple Response (expss) > Multiple Response Frequencies
  70. Multiple Response (expss) > Raw Counts (Pivot)
  71. Multivariate > Multiple CA
  72. Multivariate > Simple CA
  73. Outlier tests > Chi-squared Test for Outlier
  74. Outlier tests > Dixon Test
  75. Outlier tests > Find Outlier
  76. Outlier tests > Grubbs Test
  77. Power Analysis > ANOVA (balanced one-way)
  78. Power Analysis > Chi-squared test
  79. Power Analysis > Correlation test
  80. Power Analysis > General linear model
  81. Power Analysis > Mean of a normal distribution (known variance)
  82. Power Analysis > Proportion tests
  83. Power Analysis > t-Tests of Means
  84. Psychology / Social Sciences > Bayesian > Bayesian Contingency Table
  85. Psychology / Social Sciences > Bayesian > Bayesian Correlation
  86. Psychology / Social Sciences > Bayesian > Bayesian Independent T-Test
  87. Psychology / Social Sciences > Bayesian > Bayesian One-Way ANOVA
  88. Psychology / Social Sciences > Frequentist > Correlation Matrix
  89. Psychology / Social Sciences > Frequentist > Independent T-Test
  90. Psychology / Social Sciences > Frequentist > One-Way ANOVA
  91. Psychology / Social Sciences > Frequentist > Reliability Analysis
  92. Quality Control (qcc) > Process Capability
  93. Quality Control (qcc) > Shewhart Attributes
  94. Quality Control (qcc) > Shewhart Charts (Continuous)
  95. Regression > Linear regression
  96. Shiny > Exploration > Automated EDA Report
  97. Shiny > Exploration > Quick EDA
  98. Shiny > Psychometrics > Shiny Item Analysis
  99. Shiny > Statistics > Factoshiny (PCA/CA/MCA)
  100. Shiny > Statistics > Shinystan Diagnostics
  101. Shiny > Visualization > Esquisse
  102. Shiny > Visualization > Visual Explorer
  103. Shiny > Visualization > ggplot GUI
  104. Shiny > Visualization > Pivot Table
  105. Shiny > Visualization > Professional Dynamic
  106. Structural Equation Modeling (lavaan) > Fit SEM Model
  107. Structural Equation Modeling (lavaan) > Visualize Path Diagram
  108. Survey > Create survey design
  109. Survey > Grouped Survey Analysis (by)
  110. Survey > Survey GLM
  111. Survey > Survey Mean or Total
  112. Survey > Survey Quantiles
  113. Survey > Survey Ratio
  114. Survey > Survey Table
  115. Survey > Survey Base Plots (svyplot)
  116. Survey > Graphs > questionr > Bar Chart
  117. Survey > Graphs > questionr > Histogram
  118. Survey > Graphs > questionr > Boxplot
  119. Survey > Descriptive > Frequency Table
  120. Survey > Graphs > Demographic Pyramid (apyramid)
  121. Survey > Graphs > Animation > 1. Prepare Data
  122. Survey > Graphs > Animation > 2. Animated Bubble Chart
  123. Survey > Graphs > ggGraphs > Line Graph
  124. Survey > Graphs > ggGraphs > Means Graph
  125. Survey > Graphs > ggGraphs > Bar Diagram
  126. Survey > Graphs > ggGraphs > Box Plot
  127. Survey > Graphs > ggGraphs > Hexbin Plot
  128. Survey > Graphs > ggGraphs > Histogram
  129. Survey > Graphs > Storytelling with Data > Survey Line Graph (svyby)
  130. Survey > Graphs > Storytelling with Data > Survey Means Graph (Dots)
  131. Survey > Graphs > Storytelling with Data > Survey Bar Chart
  132. Survey > Graphs > Storytelling with Data > Big Number Summary
  133. Survival Analysis (survminer) > Cox Diagnostics
  134. Survival Analysis (survminer) > Cox Kaplan-Meier
  135. Survival Analysis (survminer) > CoxPH
  136. Teaching > Concordance > Cohen’s Kappa
  137. Teaching > Concordance > Intraclass Correlation
  138. Teaching > Data > Data Standardization
  139. Teaching > Data > Data Weighting
  140. Teaching > Non-parametric Tests > Chi-square goodness of fit
  141. Teaching > Non-parametric Tests > Friedman test for repeated measures
  142. Teaching > Non-parametric Tests > McNemar test of independence
  143. Teaching > Parametric Tests > Fisher’s F test
  144. Teaching > Parametric Tests > Levene’s test
  145. Teaching > Parametric Tests > Sample size to estimate one proportion
  146. Teaching > Parametric Tests > Test for comparing two proportions
  147. Teaching > Parametric Tests > Test for one proportion
  148. Teaching > Parametric Tests > Test for the variance of one population
  149. Teaching > Regression > Models Comparison
  150. Teaching > Regression > Nonlinear Regression
  151. Teaching > Regression > Predictions
  152. Text analysis > Frequency analysis
  153. Text analysis > Hyphenation
  154. Text analysis > Lexical diversity
  155. Text analysis > Readability
  156. Text analysis > Tokenizing POS tagging
  157. Text Mining > 1. Build and Clean Corpus
  158. Text Mining > 2. Inspect Corpus
  159. Text Mining > 3. Advanced Cleaning and Stemming
  160. Text Mining > 4. Frequencies and DTM Matrix
  161. Text Mining > 5. Word Associations
  162. Time Series > Box-Pierce or Ljung-Box Tests
  163. Time Series > Hodrick-Prescott Filter
  164. Time Series > KPSS Test for Stationarity
  165. Time Series > Phillips-Perron Test
  166. Variances / Scale > Nonparametric tests > Ansari-Bradley Two-Sample Exact Test
  167. Variances / Scale > Nonparametric tests > Ansari-Bradley Two-Sample Test
  168. Variances / Scale > Nonparametric tests > Flinger-Killeen Test
  169. Variances / Scale > Nonparametric tests > Mood Two-Sample Test
  170. Variances / Scale > Parametric tests > Barlett Test
  171. Variances / Scale > Parametric tests > F-Test
  172. Variances / Scale > Parametric tests > Levene’s Test
  173. Wilcoxon tests > Wilcoxon/Mann-Whitney
  174. 173 + 63 distribution dialogs = 236 analytics dialogs

Generated R Code

One of the aspects that most differentiates the various GUIs for R is the code they generate. This code can help you learn to program in R. It is also helpful for documenting the analysis steps and for reproducing and perhaps automating them. But what type of code is best for you? The base R code provided by R Commander? Tidyverse-style code provided by BlueSky Statistics? The concise functions that mimic the simplicity of one-step dialogs jamovi provides?

The RKWard developers chose to display base R code that will maximize what you will learn about R by not hiding any of the behind-the-scenes complexity involved. For example, to get the mean and standard deviation for two variables, RKWard generates this code:

local({
## Compute
vars <- rk.list (Penguins[["bill_depth_mm"]], Penguins[["bill_length_mm"]])
results <- data.frame ("Variable Name"=I(names (vars)), check.names=FALSE)
for (i in 1:length (vars)) {
	var <- vars[[i]]

	results[i, "Mean"] <- mean(var,na.rm=TRUE)
	results[i, "sd"] <- sd(var,na.rm=TRUE)
	
	# robust statistics
}

## Print result
rk.header ("Univariate statistics", parameters=list("Omit missing values"="yes"))

rk.results (results)
})

This might seem daunting at first, leaving a beginner to sift through it to find that mean(var, na.rm = TRUE) is the function that calculates the mean. However, someone coming from another programming language will quickly see how to code a “for” loop in R. Keep in mind that people not wanting to learn to code in R will not even see this code unless they ask to.

Support for Programmers

While I’m focusing on interfaces that include menus and dialog boxes for non-programmers, people wishing to blend that work style with programming should know that most R GUIs offer very simple R code editors. People who spend much time with R code tend to use powerful Integrated Development Environments (IDEs) like RStudio.

RKWard offers a powerful and comprehensive IDE that helps programmers write and debug code. The output from running code appears in the console window, while the output created by dialogs appears in the Output tab. The IDE features of RKWard are very similar to those of RStudio.

Its code editor, Kate, has its own open-source project, and it is jam-packed with advanced features: https://kate-editor.org/about-kate/. It supports syntax highlighting, provides hints on function arguments, offers to complete object names, and more. That’s great for people wanting to execute code, but for point-and-click users, it means that there’s a lot of added complexity.

Reproducibility & Sharing

One of the biggest challenges that GUI users face is being able to reproduce what they did. Reproducibility is useful for re-running everything on the same dataset if you find a data entry error. It’s also useful for applying your work to new datasets so long as they use the same variable names (or the software can handle changes). Some scientific journals ask researchers to submit their files (usually code and data) along with their written reports so that others can check their work.

As important a topic as it is, reproducibility is a problem for GUI users, a problem that has only recently been solved by some software developers. Most GUIs (e.g., R Commander) save only code, and it’s not code the GUI users wrote, so they also can’t read it! Others, such as jamovi and BlueSky, save the dialog box entries, providing GUI users reproducibility in their preferred form.

RKWard does save dialog box settings for you to reuse. If you execute a plot or an analysis using a dialog, then decide to do a variation on that step, choosing the dialog box again will show you one devoid of your previous choices. You might think that it has “forgotten” them. However, in the output window, each step ends with the link “Run again.” Clicking that link will make the dialog reappear, complete with your last settings filled in.

If you do “run again,” the new output will appear immediately below the existing version. That’s the most convenient approach, as you’re likely to want them close for comparison purposes, but it would be nice to have the option to have it appear at the bottom of all output.

If you wish to share your work with colleagues, you would have two choices. If they’re GUI users, you would send them your data and your RKWard output/code file. They would install RKWard, open the RKWard file, change the pointer to the new data set location, and begin work. However, output files do not contain any graphs.

If your colleagues are R programmers, you could send them your data and send them your R code. They would need to install RKWard to execute the code.

Output & Report Writing

Ideally, output should be clearly labeled, well organized, and of publication quality. It might also delve into word processing through R Markdown or LaTeX documents. Several R GUIs, such as BlueSky and jamovi, meet these requirements. See the separate reviews to see how each package works on this topic.

The labeling of RKWard’s output is done via default titles, which reflect each step well but cannot be changed in the dialog boxes. So, if you try five variations of a regression model, you’ll see five sets of output, all labeled “Linear Regression.”

The output is organized in time order only; you cannot delete any of your steps. This often results in an output file filled with unneeded results. The upper right side of the output window has a “Show TOC” link, which displays a Table of Contents. Each entry is a link that jumps you directly to that part of the output, which is very convenient. Tables of contents are commonplace for GUIs to let you re-order, rename, or delete bits of output, but none of that is possible here.

RKWard’s output quality from all GUI dialogs is very high, with nice fonts and true rich text tables. That means you can paste them into any word processor and reformat them quickly. That helps speed up your work as R output defaults to mono-spaced fonts that require additional steps to get into publication form (e.g., using functions from packages such as xtable or texreg).

RKWard now offers support for R Markdown, which allows it to save a wide variety of output file formats including Beamer, HTML, Word, Markdown, ODT, PDF, PowerPoint, RTF, DocuWiki, MediaWiki, and Vignette.

Group-By Analyses

Repeating an analysis on different groups of observations is a core task in data science. Software needs to provide an ability to select a subset one group to analyze, then another subset to compare it to. All GUIs, including RKWard, perform that task. It also needs the ability to automate such selections so that you might generate dozens of analyses, one group at a time. While this has been available in commercial GUIs for decades, only one R GUI, BlueSky, includes that feature.

Output Management

Output management deals with the software’s ability to create new data sets from the output of an analysis. That output can then be used as input for further analysis. Such data can be observation-level, such as predicted values for each observation or case. When group-by analyses are run, the output can also be model-level, such as one R-squared value for each group’s model, or parameter-level, such as the p-value for each regression parameter for each group’s model. (Saving and using models themselves is covered under “Modeling” above.)

For example, in our organization, we have 250 departments and want to see if any have a gender bias on salary. We write all 250 regression models to a data set and then search to find those whose gender parameter is significant (hoping to find none, of course).

RKWard’s modeling dialogs have the ability to save observation-level information such as predicted values and residuals. Since RKWard has such a nice spreadsheet data editor, you might expect your new variables to be saved to your original dataset, where you can view them. However, by default, they are instead saved as individual vectors.

Since RKWard lacks the ability to perform group-by processing, it has no ability to save model-level information, nor can it save parameter-level results for further analysis.

Developer Issues

The RKWard development team has created a set of tools to help R package developers to convert their work into RKWard plugins. The process consists of creating dialog boxes and determining their place on the menu structure and adding formatting to output, so that true tables appear along with quality fonts.

Conclusion

RKWard is a powerful front-end to the R language, one that provides easy point-and-click control for GUI users. People interested in learning the base R language will gain a great deal from the R code that RKWard generates. It is extremely clear R code, hiding very little within custom functions (much less than other user interfaces). Hopefully, the issue of R crashing on Macs will be remedied in the near future.

For R power users, RKWard offers a complete integrated development environment that is roughly equivalent to RStudio or Eclipse StatET.

If you want to expand your R user interface horizons, take RKWard out for a test drive and see how you like it!

For a summary of all my R GUI software reviews, see the article, R Graphical User Interface Comparison.

Acknowledgments

Thanks to Thomas Friedrichsmeier, Meik Michalke, and the RKWard team for creating RKWard and giving it away for us all to use. A special thanks to Thomas Friedrichmeier for his many suggestions that improved this article. Thanks to Alfonso Cano Robles for providing updated lists of dialogs. Also, thanks to Rachel Ladd for her editorial suggestions.