A Comparative Review of the jamovi GUI for R

by Robert A. Muenchen, updated September July 23, 2026

Introduction

jamovi (spelled with a lowercase “j”) is a free and open-source graphical user interface for the R programming language. It is available for Windows, Mac, Linux, and even ChromeOS. Versions are also planned for servers and tablets. This is one of a series of reviews that aim to help non-programmers choose the Graphical User Interface (GUI) for R that is best for them. Additionally, these reviews include cursory descriptions of the programming support that each GUI offers.

I have joined the BlueSky Statistics development team and written the BlueSky User Guide (online here), but you can trust this review series, as described 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. jamovi’s main screen.

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 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 don’t have the time or inclination 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 RKWard, install in a single step. Others install in multiple steps, such as R Commander (two steps) and Deducer (up to seven steps). Advanced computer users often don’t appreciate how lost beginners can become while attempting even a simple installation. The HelpDesks at most universities are flooded with such calls at the beginning of each semester!

jamovi’s single-step installation is extremely easy and includes its own copy of R. So if you already have a copy of R installed, you’ll have two after installing jamovi. That’s a good idea, though, as it guarantees compatibility with the version of R it uses. Python is also installed with jamovi, but it is used only for internal purposes. You can directly control only R through jamovi.

Plug-in Modules

When choosing a GUI, one of the most fundamental questions is: what can it do for you? 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 activity level ranges from very low (RKWard, Deducer) to very high (R Commander).

jamovi has an active development community which has created 76 plug-ins called “modules.” They are found in the “jamovi library” rather than on the Comprehensive R Archive Network (CRAN), where R and most of its packages are found. This makes locating and installing jamovi modules especially easy.

Some user interfaces for R, such as BlueSky and Rkward, start by double-clicking on a single icon, which is great for people who prefer not to write code. Others, such as R Commander and JGR, have you start R, then load a package from your library, and then call a function to finally activate the GUI. That’s more appropriate for people looking to learn R, as those are among the first tasks they’ll have to learn anyway.

You start jamovi directly by double-clicking its icon from your desktop or choosing it from your Start Menu (i.e. not from within R itself). It interacts with R in the background; you never need to be aware that R is running. jamovi’s menus are initially sparse, extending if you choose to add additional modules. That keeps the menus sparse and easy to use.

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 BlueSky, let you create only what R calls a data frame. They use more common terminology and call it a data set: you create one, you save one, later you open one, then you use one. Others, such as RKWard, 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 choose a dataset from within it.

jamovi’s data editor appears at start-up (Figure 1, left) and prompts you to enter data with an empty spreadsheet-style data editor. You can start entering data immediately, though at first, the variables are simply named A, B, C….

To change metadata, such as variable names, you double-click on a name, and a window (Figure 2) will slide open from the top with settings for a variable name, description, measurement level (continuous, ordinal, nominal, or ID), data type (integer, decimal, text), variable levels (labels), and a “retain unused levels” switch. Currently, jamovi has no date format, which is a serious limitation if you deal with that popular data format.

jamovi data editor settings
Figure 2. The jamovi data editor with the variable attributes window open, allowing you to make changes.

When choosing variable terminology, R GUI designers have two choices: follow what most statistics books use or instead use R jargon. The jamovi designers have opted for the statistics book terminology. For example, what jamovi calls categorical, decimal, or text are called factor, numeric, or character in R. Both sets of terms are fairly easy to learn. You can change variable settings of many variables at once, which is an important time-saver.

You can enter integer, decimal, or character data in the editor right after starting jamovi. It will recognize those types and set their metadata accordingly.

To enter nominal/factor data, you are free to enter numbers, such as 1/2, and later set levels to see, e.g., Male/Female appear. Or you can set it up in advance and enter the numbers, which will instantly turn into labels. That is a feature that saves time and helps assure accuracy. All data editors should offer that choice!

Adding observations to an existing dataset is as simple as scrolling beyond the set’s current limits and entering additional data. jamovi does not require “add more” buttons like some of its competitors (e.g., BlueSky) do. Adding variables or observations in between existing ones is also easy. Under the “Data” tab, there are two sets of “Add” and “Delete” buttons. The first set deals with variables, and the second with cases. You can use the first set to insert, compute, transform variables, or delete variables. The second inserts, appends, or deletes cases. These two sets of buttons are labeled “Variables” and “Rows,” but the font used is so small that I used jamovi for quite a while before noticing these labels.

Data Import

The ability to import data from a wide variety of formats is extremely important; you can’t analyze what you can’t access. Most of the GUIs evaluated in this series can open a wide range of file types and even pull data from relational databases. jamovi can’t read data from databases, but it can import the following file formats:

  1. Comma Separated Values (.csv)
  2. Plain text files (.txt)
  3. Excel (.xls)
  4. Excel (.xlsx)
  5. Open Document (.ods)
  6. R data files (.RData)
  7. R data files (.RDS)
  8. SPSS (.sav)
  9. SPSS (.zsav)
  10. SPSS Portable (.por)
  11. SAS binary files (.sas7bdat)
  12. SAS export (.xpt)
  13. Stata (.dta)
  14. JASP (.jasp)
  15. JSON

While jamovi doesn’t support true date/time variables, when you import a dataset that contains them, it will convert them to an integer value representing the number of days since 1970-01-01 and assign them labels in the YYYY-MM-DD format.

Data Export

The ability to export data to a wide range of file types helps when you have to use multiple tools to complete a task. Research is often a team effort, and in my experience, it’s rare for all team members to prefer the same tool. For these reasons, GUIs such as BlueSky and Deducer offer many export formats. Others, such as R Commander and RKward, can create only delimited text files.

jamovi uses project files, which combine one dataset with its associated analyses. To save just the dataset, you use the main (a.k.a. hamburger) menu to select “Export” and then “Data.”  The export formats supported are the same as those provided for import, except for JASP, JSON, and the more rarely-used ones such as SAS xpt and SPSS por and zsav:

  1. Comma Separated Values (.csv)
  2. Plain text files (.txt)
  3. Excel (.xlsx)
  4. Open Document (.ods)
  5. R data files (.RData)
  6. R data files (.RDS)
  7. SPSS (.sav)
  8. SAS binary files (.sas7bdat)
  9. SAS export (.xpt)
  10. Stata (.dta)

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; strings and dates need to be manipulated; missing values need to be handled; datasets need to be sorted, stacked, merged, aggregated, transposed, or reshaped (e.g., from “wide” format to “long” and back).

An essential aspect of data management is the ability to transform many variables at once. For example, social scientists need to recode many survey items, biologists need to take the logarithms of many variables. Doing these types of tasks one variable at a time is tedious. Some GUIs, such as BlueSky and R Commander, can handle nearly all of these tasks. Others, such as RKWard, handle only a few of these functions.

jamovi’s data management capabilities are a mixed bag. You can transform or recode variables, and doing so across many variables is easy. The transformations are stored in the variable itself, making it easy to see what was done by double-clicking its name. However, the R code for the transformation is not available, even with Syntax Mode turned on. In addition, all output tables are tied to the current state of the data editor. So, changing an existing variable also changes any previous output that involved that variable. Spreadsheet users will find this to be “business as usual”, but people coming from other analytic software or programming languages may be quite surprised. Once aware of the situation, it is easy to avoid trouble by storing transformed variables under new names. That is a good policy to follow regardless.

For stacking datasets with common variables, jamovi has one of the easiest approaches I’ve ever seen. With other GUIs, you would open one dataset, then the other, then conclude with the stacking operation. That leaves you wondering how to handle dozens of datasets. Importing many datasets is usually viewed as a separate problem to solve. jamovi is limited to having only one dataset open at a time, but it makes the most of it by allowing you to import many datasets at once, and it will stack them automatically!

You can also filter cases to work on a subset of your data. Add-on modules provide the ability to sort, merge, aggregate, transpose, or reshape datasets. Only one dataset can exist in a given jamovi analysis file, but a major structural change will open a new instance of jamovi complete with the new dataset form. Items that perform data management include:

Package Name: Menu Name: Dialog Name

  1. Variables: Compute
  2. Variables: Transform
  3. Variables: Add: Data Variable: Insert
  4. Variables: Add: Data Variable: Append
  5. Variables: Add: Data Variable: Computed: Insert
  6. Variables: Add: Computed: Append
  7. Variables: Delete
  8. Filters: Rows
  9. Data: Paste
  10. Data: Setup
  11. Data: Weights
  12. Data: Add:
  13. Data Variable: Insert (this set repeated)
  14. Data: Add: Data Variable: Append
  15. Data: Add: Data Variable: Computed: Insert
  16. Data: Add: Computed: Append
  17. Data: Delete
  18. Data: Filters
  19. Data: Add: Insert (row)
  20. Data: Add: Insert (col)
  21. Data: Delete Rows
  22. jTransform: Search
  23. jTransform: Replace
  24. jTransform: Sort
  25. jTransform: Change Variable Order
  26. jTransform: Long to Wide
  27. jTransform: Wide to Long
  28. jTransform: Transpose
  29. jTransform: Merge (Add Columns)
  30. jTransform: Combine Columns
  31. jTransform: Aggregate
  32. jTransform: Transform (Reduce Skewness)
  33. jTransform: Calculate Distances
  34. jReshape: Wide to Long
  35. jReshape: Long to Wide
  36. jReshape: Merge Columns

Menus & Dialog Boxes

The goal of pointing and clicking your way through an analysis is to save time by recognizing menu settings rather than performing the more difficult task of recalling programming commands. Some GUIs, such as BlueSky, make this easy by sticking to menu standards and using simpler dialog boxes; others, such as RKWard, use unique non-standard menus so they require more learning.

jamovi uses standard menus to perform its tasks. Dialog boxes appear, and you select variables to place into their various roles. You can either drag the variable names or select them and click an arrow located next to the particular role box. As soon as you fill in enough options to perform an analysis, its output appears instantly. There is no “OK” or “Run” button as in other GUIs reviewed here. After that, every option chosen adds to the output immediately; every option turned off is removed.

While nearly all GUIs keep your dialog box settings during your session, jamovi keeps those settings in its main “workspace” file. This allows you to return to a given analysis at a future date and try some model variations. You only need to click on the output of any analysis to cause the dialog box to appear to the right of it, complete with all settings intact.

Under the triple-dot menu on the upper right side of the screen, you can choose to run “Syntax Mode.” When you turn that on, the R syntax appears immediately, and when you turn it off, it vanishes just as quickly. Turning on syntax mode is the only way a jamovi user would notice that R is doing the work in the background.

You save your output using the standard “Menu> Save” selection.

Documentation & Training

The jamovi User Guide covers the basics of using the software. The Resources by the Community web page provides links to a helpful array of documentation and tutorials in written and video form.

Help

R GUIs provide simple task-by-task dialog boxes, which generate much more complex code. So, for a particular task, you might want to get help on 1) the dialog box’s settings, 2) the custom functions it uses (if any), and 3) the R functions that the custom functions use. Nearly all R GUIs provide all three levels of help when needed. The notable exception is the R Commander, which lacks help on the dialog boxes themselves.

jamovi doesn’t offer integrated help files, only the documentation described in the Documentation & Training section above. The search for help can become very confusing. For example, after doing the scatterplot shown in the next section, I wondered if the scat() function offered a facet argument; normally this would be an easy question to answer. My initial attempt was to go to RStudio, load jamovi’s jmv package, knowing I routinely get help from it. However, the scat() function is not built into jamovi (or jmv); it comes in the scatr add-on module. So I had to return to jamovi and install the Rj Editor module. That module lets you execute R code from within jamovi. However, running “help(scat)” yielded no result. After so much confusion, I could not find any help on that function. Hopefully, this situation will improve as jamovi matures. Of course, a non-programmer would have simply looked in the dialog box, seen the lack of a facet feature, and then assumed it did not exist.

Graphics

The various GUIs available for R handle graphics in several ways. Some, such as RKWard, focus on R’s built-in graphics. Others, such as BlueSky, focus on R’s popular ggplot graphics. GUIs also differ greatly in how they control the style of the graphs they generate. Ideally, you could set the style once, and then all graphs would follow it.

jamovi uses its own graphics functions to create plots. By default, they have the look of the popular ggplot2 package even though it uses its own functions to create them. Those functions call ggplot2 functions, so the result is the same, though the code is different, should you choose to display it. jamovi is the only R GUI I have reviewed besides BlueSky that lets you set the plot style in advance, and all future plots will use that style. It does this using four popular themes. jamovi also lets you choose color palettes in advance, from a set of eight.

jamovi can save plots in PDF, PNG, SVG, and EPS formats.

Here is the selection of plots that the main installation of jamovi can create. As with all the R GUis, many of jamovi’s statistical methods also provide plots, which are not listed here.

  1. Exploration> Descriptives – Bar Plot of Counts
  2. Exploration> Descriptives – Bar Plot of Means
  3. Exploration> Descriptives – Box Plot of Medians
  4. Exploration> Descriptives – Box Plot of Means
  5. Exploration> Descriptives – Density
  6. Exploration> Descriptives – Histogram
  7. Exploration> Descriptives – QQ Plot
  8. Exploration> Descriptives – Strip Plot (called “Data”)
  9. Exploration> Descriptives – Violin Plot
  10. Exploration> scatr – Scatter Plot
  11. Exploration> scatr – Pareto Chart
  12. Exploration> scatr – Scatter with fit lines
  13. Exploration> scatr – Scatter with marginal density
  14. Exploration> scatr – Scatter with a marginal box plot
  15. ClinicoPath> Alluvial Diagrams
  16. ClinicoPath> Age Pyramid
  17. ClinicoPath> Variable Tree
  18. ClinicoPath> Venn Diagram
  19. Flexplot> Barplot of counts
  20. Flexplot> Interaction plots
  21. Flexplot> Strip plot with means with confidence intervals
  22. JJStatsPlot: Distribution: Histogram
  23. JJStatsPlot: Distribution: Ridge Plot
  24. JJStatsPlot: Distribution: Waffle Charts
  25. JJStatsPlot: Continuous vs. Continuous: Scatterplot
  26. JJStatsPlot: Continuous vs. Continuous: Correlation Matrix
  27. JJStatsPlot: Continuous vs. Continuous: Hull Plot
  28. JJStatsPlot: Categorical vs. Continuous: Box-Violin Plots Between Groups
  29. JJStatsPlot: Categorical vs. Continuous: Box-Violin Plots Within Groups
  30. JJStatsPlot: Categorical vs. Continuous: Dot Chart
  31. JJStatsPlot: Categorical vs. Continuous: Raincloud Plot
  32. JJStatsPlot: Categorical vs. Continuous: Advanced Raincloud Plot
  33. JJStatsPlot: Categorical vs. Continuous: Lollipop Chart
  34. JJStatsPlot: Network: Arc Diagram
  35. JJStatsPlot: Lines: Line Chart
  36. JJStatsPlot: All-In-One: Automatic Plot Selection
  37. snowLatent> Profile Plot
  38. snowLatent> Radar Chart
  39. snowLatent> Raincloud Plot
  40. snowLatent> Wordcloud
  41. surveymv> Survey Plots
  42. ufs> Diamond Plot of Means
  43. vijPlots> Histogram (These offer different options to above plots)
  44. vijPlots> Box Plot
  45. vijPlots> Raincloud Plot
  46. vijPlots> Scatterplot
  47. vijPlots> Bar Chart
  48. vijPlots> Lollipop Chart
  49. vijPlots> Q-Q & P-P Plots
  50. vijPlots> Bar Plot
  51. vijPlots> Pie Chart
  52. vijPlots> Likert Plot
  53. vijPlots> Multiple Response Frequencies
  54. vijPlots> Multiple Response Crosstab
  55. vijPlots> Time Series Line Chart
  56. vijPlots> Time Series Area Chart
  57. vijPlots> Principal Components
  58. vijPlots> Correspondence Analysis
  59. vijPlots> Multiple Correspondence Analysis

Let’s take a look at how jamovi does scatterplots. I used the menu, “Plots> Scatterplot” and filled in the variables for x- and y-axes, the grouping variable gender, the regression line “linear,” and then I checked the “confidence interval” box. This is the plot that resulted:

jamovi Scatter Plot
Figure 3. A scatterplot done by jamovi (not using ggplot!)

Those of you who are familiar with the ggplot2 package might already be thinking of the function call that you would use to create this common plot. However, jamovi used internal functions and displayed the message, “Syntax mode for plots is not yet available.”

The flexplot plug-in adds a very useful set of plots that can be produced in small multiples, a.k.a. panel or facet plots. For example, a simple dialog box created
Figure 4.

Figure 4. A paneled (faceted) regression plot using the flexplot module.

While this looks like the plot created by ggplot2 in some of the other reviews, the code used to create it was this:

flexplot::flexplota(
  data = data,
  out = posttest,
  preds = pretest,
  given = vars(gender, workshop),
  line = "Regression",
  ghost = FALSE)

This follows the usual jamovi style of being easier to read than the usual R code used to create the plot.

However, the ability to create multiple small plots is not comprehensive. Flexplot can only create box, scatter, and bar charts (with and without confidence intervals). jamovi also lacks the ability to create large multiple plots, which reproduce the entire full-sized plot by one or more grouping factors. BlueSky Statistics and R-Instat both have that ability.

Modeling

The way statistical models (which R stores in “model objects”) are created and used is an area in which R GUIs differ the most. Some, like RKWard, use a one-step approach to modeling. That approach tries to do everything you might need in a single dialog box. This is perfect for beginners who appreciate being reminded of the various assumption tests and evaluation steps to take. But to an R programmer, that approach seems confining since R can do a lot of different tasks with model objects. However, neither SAS nor SPSS were able to save models for their first 35 years of existence, so each approach has its merits. For simple models like linear regression, standard compute statements can enter models to make predictions. Entering them manually is not much effort, and it saves you from having to learn what a model object is. However, some of the most powerful model types are essentially impossible to enter by hand, such as neural networks, random forests, and gradient-boosting machines.

Other GUIs, such as BlueSky and R Commander, do modeling using a two-step process. First, you generate and save a model, then use it for scoring new datasets, calculating model-level measures of fit or observation-level scores of influence, diagnostic plotting, testing differences between models, and so on.

jamovi follows the one-step approach. It can save predicted values, residuals, and Cook’s distance for the current dataset. However, it does not save models, so you need to use compute statements to enter a model and apply it to a new data set (or a hold-out sample) to see how effectively the model generalizes. This is great for intro statistics courses but lacks the flexibility that more advanced researchers might prefer.

Another way in which R GUIs differ is the model formula builder. Some, like JASP and RKWard, offer only the most popular model types, providing interactions and allowing you to force the y-intercept through zero. Others, such as R Commander and BlueSky, offer maximum power by including buttons to control nested factors, polynomials, splines, etc.

Jamovi keeps model formulas simple. It offers two arrows with which to add model terms. Clicking the top one adds the terms you select and all possible interactions. That can signal that you don’t have enough degrees of freedom, allowing you to remove terms. Alternatively, you can use the bottom arrow to add main effects with one click, add 2-way interactions with a second click, and so on until you have the model you need. Its model builder also includes the ability to enter predictors in blocks, obviating the need to create two models, then run a test to compare them. Since jamovi’s model builder does not offer advanced features like nested effects and splines, those models cannot be done. The model it builds is not displayed as a standard R formula, which you could modify manually.

Jamovi’s model builder also allows you to set reference levels for factors, which is typically a separate step in other R GUIs. That’s a nice touch!

If you work with datasets with a million or more cases, modeling in jamovi is quite a bit slower than the other R GUIs that pass their code directly to R. However, those other GUIs lack immediate feedback for each dialog box selection.

Analysis Methods

All of the R GUIs offer a decent set of statistical analysis methods. Some also offer machine learning methods. As you can see from the list below, jamovi’s set of analysis methods is quite extensive.

Module Name: Menu Name: Dialog Name

  1. jmv: Exploration: Descriptives
  2. jmv: T-Tests: Independent Samples T-Test
  3. jmv: T-Tests: Paired Samples T-Test
  4. jmv: T-Tests: One Sample T-Test
  5. jmv: ANOVA: ANOVA
  6. jmv: ANOVA: One-Way ANOVA
  7. jmv: ANOVA: Repeated Measures ANOVA
  8. jmv: ANOVA: ANCOVA
  9. jmv: ANOVA: MANCOVA
  10. jmv: ANOVA: Non-parametric: One-Way ANOVA
  11. jmv: ANOVA: Non-parametric: Repeated Measures ANOVA
  12. jmv: Regression: Correlation Matrix
  13. jmv: Regression: Partial Correlation
  14. jmv: Regression: Linear Regression
  15. jmv: Regression: Logistic Regression: (2 Outcomes)
  16. jmv: Regression: Logistic Regression: (N Outcomes)
  17. jmv: Regression: Logistic Regression: (Ordinal Outcomes)
  18. jmv: Frequencies: Proportion Test (2 Outcomes)
  19. jmv: Frequencies: Proportion Test (N Outcomes)
  20. jmv: Frequencies: Contingency Tables, Independent
  21. jmv: Frequencies: Contingency Tables, Paired
  22. jmv: Frequencies: Log-Linear Regression
  23. jmv: Factor: Scale Analysis: Reliability Analysis
  24. jmv: Factor: Data Reduction: Principal Component Analysis
  25. jmv: Factor: Data Reduction: Exploratory Factor Analysis
  26. jmv: Factor: Data Reduction: Confirmatory Factor Analysis
  27. jsq: Bayesian Independent Samples T-Test
  28. jsq: Bayesian Paired Samples T-Test
  29. jsq: Bayesian One Sample T-Test
  30. jsq: Bayesian ANOVA
  31. jsq: Bayesian Repeated Measures ANOVA
  32. jsq: Bayesian ANCOVA
  33. jsq: Bayesian Correlation Matrix
  34. jsq: Bayesian Correlation Pairs
  35. jsq: Bayesian Contingency Tables
  36. jsq: Bayesian Linear Regression
  37. jsq: Bayesian Log-Linear Regression
  38. jsq: Bayesian Proportion Test (2 Outcomes) 
  39. ASVD: ASVD Protocol
  40. Behavior Change: Acyclic Behavior Change Diagram (ABCD)
  41. Behavior Change: CIBERlite Plot
  42. Behavior Change: Confidence Interval-Based Estimation of Relevance (CIBER)
  43. Behavior Change: Meaningful Change Definition (MCD) to Cohen’s d
  44. Behavior Change: Number Needed to Change (NNC estimated with NNT)
  45. blandr: Bland-Altmant Analysis
  46. blandr: Differences Q-Q Plot
  47. blandr: Differenes Histogram and Density Curve
  48. blandr: Bland-Altman Raw Statistics    
  49. bmtest: Brunnel-Munzer Test  
  50. BrawStats: Learn Basics
  51. BrawStats: Run Simulations
  52. BrawStats: Analyze Data  
  53. BSS: Comparisons: Compare Correlations
  54. BSS: Missing Data Imputation: MissRanger Imputation
  55. BSS: Missing Data Imputation: Multiple Imputation by Chained Equations (MICE)
  56. BSS: Outlier Detection: IQR Method
  57. BSS: Outlier Detection: Modified Z-Score Method
  58. BSS: Outlier Detection: Dixon’s Q Test
  59. BSS: Network Analysis: For continuous data
  60. BSS: Network Analysis: For mixed data
  61. BSS: Post-hoc for Discriminant / MANOVA
  62. BSS: Sample Size Calculation: Animal Design Resource Equation Approach
  63. BSS: Sample Size Calculation: Finite Population Cochran and Slovin Formulas        
  64. Chi-Squared Tools: Test of Independence
  65. Chi-Squared Tools: Association & Effect Sizes
  66. Chi-Squared Tools: Post-Hoc Analysis
  67. Chi-Squared Tools: Power Analysis
  68. Chi-Squared Tools: Table Reduction (SRD)
  69. Chi-Squared Tools: Row/Column Clustering
  70. Chi-Squared Tools: Stratified Analysis (2x2xK)
  71. Chi-Squared Tools: Stratified Analysis (RxCxK)
  72. ClinicoPath: Data Preparation: Categorize Continuous Variables
  73. ClinicoPath: Descriptives: Table One
  74. ClinicoPath: Descriptives: Summary of Continuous Variables
  75. ClinicoPath: Descriptives: Summary of Categorical Variables
  76. ClinicoPath: Data Quality: Benford Analysis
  77. ClinicoPath: Data Quality: Single Variable Quality Check
  78. ClinicoPath: Data Quality: Multi-Variable Quality Check
  79. ClinicoPath: Data Quality: Outlier Detection
  80. ClinicoPath: Comparisons: Cross Tables
  81. ClinicoPath: Comparisons: Chi-Squared Post-Hot Testss
  82. clt: Tossing Coint
  83. clt: Throwing Dice
  84. clt: Central Limit Theorem
  85. clt: Correlation
  86. clt: Testing Hypothesis
  87. cNORMj: Analyses: Single Group
  88. cNORMj: Analyses: Continuous Norming (Distribution Free)
  89. cNORMj: Analyses: Continous Norming (Beta Binomial)      
  90. CompositeSEM: Composite Structural Equation Modeling
  91. deathwatch: Survival Analysis  
  92. deval: ROC Analysis       
  93. DiagROC: ROC Analysis
  94. DiagROC: Optimal Cut-off Selection
  95. DiagROC: Manual Calculator
  96. DiagROC: Sample Size Estimation     
  97. distrACTION: Continuous: Normal
  98. distrACTION: Continuous: T-Distribution
  99. distrACTION: Continuous: Chi-Squared Distribution
  100. distrACTION: Continuous: F-Distribution
  101. distrACTION: Discrete Distributions: Binomial
  102. distrACTION: Discrete Distributions: Poisson
  103. easyRasch2jmv: Analysis: Conditional Item Fit
  104. easyRasch2jmv: Analysis: Item-Restscore Correlations
  105. easyRasch2jmv: Analysis: Bootstrip Item-Restscore
  106. easyRasch2jmv: Analysis: Conditional Item Infit (Multiple Imputation)
  107. easyRasch2jmv: Analysis: Dynamic CFA Fit-Index Cutoffs
  108. easyRasch2jmv: Analysis: PCA of Standardized Rasch Residuals
  109. easyRasch2jmv: Analysis: Martin-Lof Test
  110. easyRasch2jmv: Analysis: Partial Gamma Local Dependence
  111. easyRasch2jmv: Analysis: Q3 Residual Correlation Matarix
  112. easyRasch2jmv: Analysis: Andersen LR-test DIF
  113. easyRasch2jmv: Analysis: Tree-Based DIF
  114. easyRasch2jmv: Analysis: Partial Gamma DIF
  115. easyRasch2jmv: Analysis: Item Characteristic Curves (CICC)
  116. easyRasch2jmv: Analysis: Item Probability Curves
  117. easyRasch2jmv: Analysis: Targeting Plot
  118. endoj: Instrumental Variables Model       
  119. esci: Describe
  120. esci: Single Group
  121. esci: Two Groups
  122. esci: Paired
  123. esci: Independent Groups Contrast
  124. esci: 2×2 Factorial
  125. esci: Correlations: Single Group
  126. esci: Correlations: Two Groups
  127. esci: Proportions: Single Group
  128. esci: Proportions: Two Groups
  129. esci: Proportions: Paired
  130. esci: Meta-Analysis: Means
  131. esci: Meta-Analysis: Difference in Means
  132. esci: Meta-Analysis: Correlations
  133. esci: Meta-Analysis: Proportions
  134. esci: Meta-Analysis: Difference in Proportions
  135. flexplot: General Linear Model (see also Graphics section above)    
  136. FoodieStats: Create an Experimental Design
  137. FoodieStats: 2k Experimental Design
  138. FoodieStats: Response Surface Design
  139. FoodieStats: Mixture Design
  140. FoodieStats: Desirability Optimization
  141. FoodieStats: Just-About-Right Analysis
  142. FoodieStats: Check All That Apply     
  143. GAMLj3: General Linear Model
  144. GAMLj3: Linear Mixed Model
  145. GAMLj3: Generalized Linear Model
  146. GAMLj3: Generalized Mixed Model      
  147. jamm: GLM Mediation Model        
  148. JAR: Analyses: Just-about-right analysis         
  149. jeva: T-Tests: Independent Samples T-Test
  150. jeva: T-Tests: Paired Samples T-Test
  151. jeva: T-Tests: One Sample T-Test
  152. jeva: T-Tests: Sample Size Calculator
  153. jeva: ANOVA: One-Way ANOVA
  154. jeva: ANOVA: Two-Way ANOVA
  155. jeva: ANOVA: Repeated Measures ANOVA
  156. jeva: Regression & Correlation: Polynomial Regression
  157. jeva: Regression & Correlation: Correlation
  158. jeva: Categorical Data: N Outcomes
  159. jeva: Categorical Data: Independent Samples
  160. jeva: Categorical Data: Odds Ratio
  161. jeva: Categorical Data: Relative Risk
  162. jeva: Categorical Data: Paired Samples
  163. jeva: Categorical Data: Diagnostic Test
  164. jjstatsplot 
  165. jMDS: Multidimensional Scaling           
  166. jpower: Independent Samples T-Test
  167. jpower: Paired Samples T-Test
  168. jpower: One Sample T-Test
  169. jSumTTest: Analysis: Summary Data   
  170. jsurvival: ClinicoPath Survival: Single Arm Survival
  171. jsurvival: ClinicoPath Survival: Survival Analysis
  172. jsurvival: ClinicoPath Survival: Survival Analysis for Continuous Variable
  173. jsurvival: ClinicoPath Survival: Multivariable Survival Analysis
  174. jsurvival: General Statistics: Odds Ratio Table and Plot
  175. jsurvival: Data Preparation: DateTime Converter
  176. jsurvival: Data Preparation: Comprehensive Time Interval Calculator
  177. jsurvival: Data Preparation: Outcome Organizer for Survival Analysis
  178. JTNA: Transition Network Analysis
  179. JTNA: Group Transition Network Analysis
  180. JTNA: Cluster Transition Network Analysis        
  181. jYS: Correlation Clustering
  182. jYS: Principal Component Analysis
  183. jYS: ROC Classification
  184. jYS: MLP Classifier
  185. jYS: Logistic Regression
  186. jYS: Survival Analysis
  187. jYS: Missing Values Estimation and Imputation
  188. jYS: Univariate outliers identification and removal
  189. jYS: Multivariate outliers identification and removal
  190. jYS: Uncertain Interval (UI)
  191. jYS: Single Nucleotide Polymorphism
  192. lasars: Latent State and Response Style  
  193. lasars: Latent State Only       
  194. lsj-data    
  195. MAJOR: Correlation Coefficients (Meta Analysis)
  196. MAJOR: Dichotomous Models
  197. MAJOR: Effect Sizes and (Sampling Variances or Standard Errors)
  198. MAJOR: Mean Differences
  199. MAJOR: Proportions
  200. MAJOR: Reliability Generalization
  201. MEDA: Automatic Univariate Description: By Categorical (all via FactoMineR)
  202. MEDA: Automatic Univariate Description: By Textual
  203. MEDA: Automatic Univariate Description: By Columns/Rows
  204. MEDA: Multivariate Analysis: Principal Components Analysis
  205. MEDA: Multivariate Analysis: Correspondence Analysis
  206. MEDA: Multivariate Analysis: Multiple Correspondence Analysis
  207. MEDA: Multivariate Analysis: Multiple Factor Analysis
  208. meddecide: Agreement: Interrater Reliability
  209. meddecide: Decision: Medical Decisions
  210. meddecide: Decision: Analysis Without Gold Standard
  211. meddecide: Decision: Compare Medical Decision Tests
  212. meddecide: Decision: Combine Medical Decision Tests
  213. meddecide: Decision Calculators: Medical Decision Calculator
  214. meddecide: Decision Calculators: Co-Testing Analysis
  215. meddecide: Decision Calculators: Sequential Testing Analysis
  216. meddecide: ROC: Clinical ROC Analysis
  217. meddecide: ROC: Advanced ROC Analysis
  218. meddecide: Prediction Models: LASSO Logistic
  219. medmod: Mediation
  220. medmod: Moderation
  221. metaumbrella: Umbrella Review
  222. MLwrapj: Regression
  223. MLwrapj: Binary Classification
  224. MLwrapj: Multiclass Classification
  225. moretests: Kolmogorov-Smirnov (these add options to existing dialogs, not new ones)
  226. moretests: Anderson-Darling
  227. moretests: Bartlett’s
  228. OncoPath: Patient Follow-Up Plots: Treatment Response Waterfall, Spider
  229. OncoPath: Patient Follow-Up Plots: Swimmer Plot
  230. OncoPath: IHC Analysis: IHC Heterogeneity Analysis
  231. OncoPath: IHC Analysis: Diagnostic Test Meta-Analysis for Pathology   
  232. One Hot Encoding: One Hot Encoding
  233. pamlj: Correlation (these are all for Power Analysis)
  234. pamlj: T-Test
  235. pamlj: Proportions
  236. pamlj: General Linear Model
  237. pamlj: Factorial Designs
  238. pamlj: Mediation
  239. pamlj: Structural Equations Models
  240. pamlj: Mixed Models
  241. pathfy: Analyses: Graphical SEM  
  242. pathj: Path Analysis     
  243. PGM: Practical Growth Modeling – Curve Modeling         
  244. psychoPDA   
  245. QM: One Concept with MCA
  246. QM: Two Concepts with MFA          
  247. Randomizer: Completely Randomized Design
  248. Randomizer: Randomized Complete Block Design
  249. Randomizer: Latin Square Design        
  250. rosetta: Frequencies    
  251. saRa: Probability: Discrete Distributions: Binomial
  252. saRa: Probability: Discrete Distributions: Poisson
  253. saRa: Probability: Discrete Distributions: Negative Binomial
  254. saRa: Probability: Continuous Distributions: Normal
  255. saRa: Probability: Continuous Distributions: t
  256. saRa: Probability: Continuous Distributions: Chi-squared
  257. saRa: Probability: Continuous Distributions: F
  258. saRa: Probability: Continuous Distributions: Exponential
  259. saRa: Probability: Continuous Distributions: Uniform
  260. saRa: Univariate Analyses: Categorical Data
  261. saRa: Univariate Analyses: Ordinal Data
  262. saRa: Univariate Analyses: Numerical Data
  263. saRa: Bivariate Analyses: Categorical Data
  264. saRa: Bivariate Analyses: Ordinal Data
  265. saRa: Bivariate Analyses: Numerical Data
  266. saRa: Bivariate Analyses: Mixed Data
  267. saRa: Miscellaneous: Mann-Whitney Test
  268. saRa: Miscellaneous: Wilcoxon T Test
  269. saRa: Miscellaneous: Normality Tests        
  270. SEDA: Characterization of the Stimulus Space (all based on SensoMineR)
  271. SEDA: Representation of the Stimulus Space
  272. SEDA: Analysis of CATA Data
  273. SEDA: Analysis of JAR Data
  274. SEDA: Analysis of Napping Data
  275. SEDA: Analysis of Sorting Data
  276. SEDA: Preference Modeling
  277. SEMLj: SEM (syntax)
  278. SEMLj: SEM (interactive)   
  279. seolmatrix: Correlation: Partial & Robust
  280. seolmatrix: Correlation: Ordinal
  281. seolmatrix: Correlation: Multilevel
  282. seolmatrix: Correlation: Concordance
  283. seolmatrix: Correlation: Correlation Structure
  284. seolmatrix: Correlation: Repeated & Cross Correlation
  285. seolmatrix: Correlation: Canonical
  286. seolmatrix: Rater: Rater Reliability
  287. seolmatrix: Rater: Generalizability Theory
  288. seolmatrix: AHP: Analytic Hierarchy Process
  289. seolmatrix: AHP: AHP for Survey Data
  290. seolmatrix: Network: Directed Graph Centrality
  291. seolmatrix: Network: Group Network Comparison
  292. seolmatrix: Dimensionality: Velicer MAP Test
  293. SimplyAgree: Simple Agreement Analysis
  294. SimplyAgree: Nested/Replicate Data Agreement Analysis
  295. SimplyAgree: Reliability Analysis
  296. SimplyAgree: Deming Regression
  297. snowCluster: Cluster Analysis: K-Means Clustering 
  298. snowCluster: Cluster Analysis: Trajectory K-Means 
  299. snowCluster: Cluster Analysis: Hierarchical Clustering
  300. snowCluster: Cluster Analysis: Density-based Clustering 
  301. snowCluster: Cluster Analysis: Time Series Clustering 
  302. snowCluster: Cluster Plot: Clustering Dendrogram
  303. snowCluster: Cluster Plot: Multidimensional Scaling Plot
  304. snowCluster: Cluster Plot: Dimension Reduction Plot
  305. snowCluster: Correspondence & Factor: Correspondence Analysis
  306. snowCluster: Correspondence & Factor: Multiple Correspondence Analysis
  307. snowCluster: Correspondence & Factor: Multiple Factor Analysis
  308. snowCluster: Correspondence & Factor: Factor Analysis of Mixed Data
  309. snowCluster: Classification: Linear Discriminant Analysis
  310. snowCluster: Classification: Decision Tree
  311. snowCluster: Classification: Machine Learning
  312. snowCluster: Classification: ROC Analysis
  313. snowCluster: Time Series: Univariate Time Series
  314. snowCluster: Time Series: Prophet with Multiple Variables
  315. snowIRT: Dichotomous Model
  316. snowIRT: Polytomous Model
  317. snowIRT: Many Facet Rasch Model
  318. snowIRT: Differential Item Functioning: Raju & Mantel Haenszel Method
  319. snowIRT: Differential Item Functioning: Delta Method
  320. snowIRT: Differential Item Functioning: DIF for ordinal data
  321. snowIRT: Differential Item Functioning: Conditional Likelihood Ratio Test
  322. snowIRT: Multiple Choice: Distractor Analysis
  323. snowLatent: LCA: Latent Class Analysis
  324. snowLatent: LCA: Multiple Group LCA
  325. snowLatent: LCA: Multilevel LCA
  326. snowLatent: LCA/LPA 3-step approach
  327. snowLatent: Latent Transition Analysis (LTA)
  328. snowRMM: Rasch Model
  329. snowRMM: Rasch Mixture Model
  330. snowRMM: Bootstrap Item Fit
  331. snowRMM: Differential Item Functioning
  332. snowRMM: Basic LCA
  333. snowRMM: Ordinal LCA
  334. snowRMM: Latent Profile Analysis
  335. snowRMM: Latent Class Growth Modeling
  336. snowRMM: CTT Equating
  337. snowRMM: Composit Linking
  338. snowRMM: Linear Logistic Test Model     
  339. Statkat: Single Variable
  340. Statkat: Relationships, Prediction, and Group Comparisons
  341. Statkat: Repeated Measurements     
  342. Summary Tables: Summary Table
  343. Summary Tables: Continuous Table
  344. Summary Tables: Cross Table
  345. Summary Tables: Likert Table
  346. Summary Tables: Survival Table
  347. Summary Tables: Linear Regression
  348. Summary Tables: Logistic Regression
  349. Summary Tables: Cox Regression
  350. Summary Tables: Multiple Linear Regression
  351. Summary Tables: Multiple Logistic Regression
  352. Summary Tables: Multiple Cox Regression
  353. surveymv    
  354. TOSTER: Independent Samples T-Test
  355. TOSTER: Paired Samples T-Test
  356. TOSTER: One Sample T-Test
  357. TOSTER: Correlation
  358. TOSTER: Two Proportions
  359. ufs: Analyses: Diamond plot: Means
  360. ufs: Analyses: Effect Size Confidence Interval: Cohen’s d
  361. ufs: Analyses: Effect Size Confidence Interval: Pearson’s r
  362. ufs: Analyses: Multi Response
  363. ufs: Analyses: Sample size for accuracy: d
  364. ufs: Analyses: Sample size for accuracy: r
  365. walrus: Box & Violin Plots
  366. walrus: Robust Descriptives
  367. walrus: T-Tests: Robust Independent Samples T-Test
  368. walrus: T-Tests: Robust Paired Samples T-Test
  369. walrus: ANOVAs: Robust ANOVA
  370. ztestvis: One-sample Z-Test

Generated R Code

One of the most distinguishing attributes of the various GUIs for R is the code they generate. If you decide you want to save code, what type of code is best for you? The base R code as provided by the R Commander, which can teach you “classic” R? The tidyverse code generated by BlueSky Statistics? The completely transparent (and complex) code provided by RKWard, which might be the best for budding R power users?

When managing data, jamovi doesn’t display any syntax. For graphics and analysis, it generates code using its own functions. So if you’re planning on learning R, you won’t be learning classic R functions, nor will you be learning the popular “tidyverse” code for R. Instead,  you’ll be learning a type of code that often looks closer to SPSS than it does to R. The advantage to this is that jamovi combines many separate R packages into one, so R programmers don’t have to find and install so many packages. The disadvantage is that you don’t learn what most people would view as R code. Of course, if you plan to only point-and-click your way through analyses, you won’t care what type of code is behind the scenes.

Is it impossible for the jamovi developers to dream of replacing common functions with their own? Not at all. The extremely popular tidyverse functions don’t do anything that classic R can’t do, they just do it in a way that its adherents view as easier. The very same thing could happen via jamovi’s jmv package of functions.

Here’s an example of code jamovi used to create a two-way ANOVA:

jmv::ANOVA(
    formula = posttest ~ gender + workshop + gender:workshop,
    data = data,
    homo = TRUE,
    postHoc = ~ workshop,
    postHocCorr = "holm",
    emMeans = ~ gender:workshop)

An R user familiar with analysis of variance would not recognize that code, but would see that it was a single function call from one package rather than the usual half-dozen function calls from as many packages. It’s much simpler to learn, though less flexible. (Note that jmv functions do follow the tidyverse’s ability to accept piped input since the data argument is in the first position.)

Support for Programmers

Some of the GUIs reviewed in this series of articles include extensive support for programmers. For example, RKWard offers much of the power of Integrated Development Environments (IDEs) such as RStudio or Eclipse StatET. Others, such as jamovi or the R Commander, offer little more than a simple text editor.

The jamovi’s team’s main mission is to make their point-and-click GUI comprehensive. However, it does offer a plug-in code editor named Rj. It provides syntax highlighting (color coding) and basic code completion.

Reproducibility & Sharing

One of the biggest challenges that GUI users face is being able to reproduce their work. 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 name 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. the R Commander, Rattle) save only code, but since GUI users don’t write the code, they also can’t read it or change it! Others, such as JASP, save the dialog box entries and allow GUI users reproducibility in their preferred form.

jamovi records the steps of all analyses, providing exact reproducibility. In addition, if you update a data value, all the analyses that used that variable are recalculated instantly (such manual changes are not recorded). That’s helpful, especially for people coming from Excel who expect this to happen. In addition, jamovi allows you to create a “template” that can rerun an entire set of analyses on a new dataset with the same variable names.

If you wish to share your work with colleagues who are jamovi users, you only need to give them your jamovi workspace file. It contains everything they need in a single file. This includes the dataset used (only one is possible) and any notes you have added to the output. That comprehensive package makes organization and sharing easy, but if you store multiple analyses in separate files, each will contain the dataset, which can waste space with large files.

If your colleague is an R coder, you could export your dataset to whichever file format they need and save your jamovi code. Code export is a tedious, one-analysis-at-a-time copy-paste process. While the data management code is not exportable, the dataset itself will contain the results of those transformations. Your colleague could then install the jmv package from CRAN to run your code. Note that at the moment, the Bayesian analyses cannot display their R code, but the developers are aware of the issue and plan to fix it.

Package Management

A topic related to reproducibility is package management. One of the major advantages to the R language is that it’s very easy to extend its capabilities through add-on packages. However, updates in these packages may break a previously functioning analysis. Years from now you may need to run a variation of an analysis, which would require you to find the version of R you used, plus the packages you used at the time. As a GUI user, you’d also need to find the version of the GUI that was compatible with that version of R.

Some GUIs, such as the R Commander and Deducer, depend on you to find and install R. For them, the problem is left for you to solve. Others, such as BlueSky, distribute their own version of R, all R packages, and all of its add-on modules. This requires a bigger installation file, but it makes dealing with long-term stability as simple as finding the version you used when you last performed a particular analysis. Of course, this depends on all major versions being around for long term, but for open-source software, there are usually multiple archives available to store software even if the original project is defunct.

jamovi’s approach to package management is halfway between the above two approaches. It provides nearly everything you need in a single download. This includes the jamovi interface, the jmv package, and its dependencies, R itself, and even a version of Python which is used internally. So for the base package, you’re all set. What remains to be seen is how they manage the dates for the add-on modules. While this is a current problem with long-term reproducibility, the jamovi developers are working on solving that problem.

Output & Report Writing

Ideally, output should be clearly labeled, well organized, and of publication quality. It might also delve into the realm of word processing through R Markdown, knitr, or Sweave documents. At the moment, none of the GUIs covered in this series of reviews meets all of these requirements. See the separate reviews to see how each of the other packages is doing on this topic.

The labels for each of jamovi’s analyses are provided by its menu title. The title is easy to edit, and if you do so, a text editing control bar pops up at the top, allowing you full annotation features. I assumed these were exportable into R Markdown or the newer Quarto format, but they are not. However, there is no need to learn even the simple Markdown commands since everyone knows how to use a word processing control bar.

The organization of the output is in time order only. You can delete an analysis, but you cannot move it into an order that may make more sense after you see it.

While such tables of contents are commonly used in GUIs to let you jump directly to a section, or to re-order, rename, or delete bits of output, that feature is not available in jamovi.

Those limitations aside, jamovi’s output quality is very high, with nice fonts and true rich text tables (Figure 4). Tabular output is displayed in the popular style of the American Psychological Association. That means you can right-click on any table and choose “Copy” and the formatting is retained. That really helps speed 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). You can also export an entire set of analyses to HTML, then open the nicely-formatted tables in Word.

jamovi t-tests for review

Figure 4. Output cut from jamovi & pasted into Microsoft Word. The font was changed just to show that it’s a true table.

Group-By Analyses

Repeating an analysis on different groups of observations is a core task in data science. Software needs to provide the ability to select a subset of one group to analyze, then another subset to compare it to. All the R GUIs reviewed in this series can do this task. jamovi does single-group selections using “Data> Filters”. It generates a subset that you can analyze in the same way as the entire dataset. Given jamovi’s use of immediate feedback, switching from one filter to another immediately changes the focus of every graph and analysis you’ve done. That’s rewarding, but you can’t end up with one report that contains the results for each subset. Instead, you must save each to its own file and combine the results later in a different tool (e.g., word processor, PDF merger, etc.).

Software 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 (e.g. SPSS “split-file”, SAS “by” statement), BlueSky is the only R GUI reviewed here that includes this feature. The closest jamovi gets on this topic is to offer a “Split by” variable selection box in its Descriptives procedure.

Output Management

Early in the development of statistical software, developers tried to guess what output would be important to save to a new dataset (e.g., predicted values, factor scores), and the ability to save such output was built into the analysis procedures themselves. However, researchers were far more creative than the developers anticipated. To better meet their needs, output management systems were created and tacked on to existing tools (e.g. SAS’ Output Delivery System, SPSS’ Output Management System). One of R’s greatest strengths is that every bit of output can be readily used as input. However, with the simplification that GUIs provide, that’s a challenge.

Output data can be observation-level, such as predicted values for each observation or case.  When group-by analyses are run, the output data can also be observation-level, but now the (e.g.) predicted values would be created by individual models for each group rather than one model based on the entire original data set (perhaps with group included as a set of indicator variables).

Group-by analyses can also create model-level data sets, such as one R-squared value for each group’s model. They can also create parameter-level data sets, such as the p-value for each regression parameter for each group’s model. (Saving and using single models is covered under “Modeling” above.)

For example, in my organization, we have 250 departments and want to see if any of them 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!)

While jamovi offers observation-level output, it lacks both model-level and parameter-level model summarization. BlueSky is the only R GUI reviewed here that does all three levels of output management.

Developer Issues

The jamovi development team encourages people to develop add-on modules to expand jamovi’s capabilities. It does this through a Developer’s Hub which includes a Getting Started guide. The team also offers live workshops for developers and provides the jamovi Library, which lets you publish your modules and make them easily installable by all jamovi users.

Conclusion

jamovi is a gem of a package, one that looks so good I asked the developers if they had an artist or user interface designer on the team. They don’t, but they have clearly put a lot of thought into how to make the software beautiful and easy to use. They have also chosen their options carefully so that each analysis includes what a researcher would want to see. jamovi’s ability to save analysis templates for reuse is a feature that all GUI users will find helpful, as it makes the work reusable without having to save code. jamovi’s selection of graphics and data analysis methods is truly impressive.

Their creation of the jmv package is a bold move, one that promises to greatly simplify the number of separate packages a coder would need to learn. However, in so doing, they challenge the existing way of working with R. Just as the tidyverse set of commands is controversial, the jmv package is also likely to ruffle some feathers. However, their main audience is not likely to be concerned with the finer points of R code.

As nice as jamovi is, it lacks a few features, including the ability to see and save code for plots and data management; the ability to handle true date/time variables; the ability to use nested effects or splines in models; and the ability to save models so they can be tested on hold-out samples or applied to new data sets.

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

Acknowledgments

Thanks to Jonathan Love for his suggestions that improved this review. Thanks also to Rachel Ladd, Ruben Ortiz, Christina Peterson, and Josh Price for their editorial suggestions.