A Comparative Review of the jamovi GUI for R

by Robert A. Muenchen, updated 2/15/2021


jamovi (spelled with a lower-case “j”) is a free and open-source graphical user interface for the R software that targets beginners looking to point-and-click their way through analyses. It is available for Windows, Mac, Linux, and even ChromeOS. Versions are also planned for servers and tablets.

This post 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.

Figure 1. jamovi’s main screen.


There are various definitions of user interface types, so here’s how I’ll be using these terms:

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.


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 that it uses, plus a standard R installation by itself is harder than jamovi’s. 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? What the initial software installation of each GUI gets you is covered in the Graphics, Analysis, and Modeling sections 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, Deducer) to very high (R Commander).

For jamovi, plug-ins are called “modules” and 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.

Although jamovi is one of the most recent GUIs to appear on the R scene, it has already attracted a substantial number of developers. The list of modules at publication time is listed below. You can check on the latest ones on this web page.

  1. Base R – converts jamovi analyses into standard R functions
  2. behaviorchange – specialized analyses and visualization tools for research and application of behavior change science
  3. blandr – Bland-Altman method comparison analysis, and is also available as an R package from CRAN
  4. ClinicoPathDescriptives – descriptive functions for clinicopathological research
  5. clt – Central Limit Theorem demonstrations for teaching
  6. cNORMj – conventional and regression-based continuous norming methods for psychometric, biometric, and medical test construction
  7. deathwatch – survival analysis
  8. distrACTION – quantiles and probabilities of continuous and discrete distributions
  9. esci – effect sizes and confidence intervals
  10. flexplot – graphically-based tools for data analysis; user supplies a formula and the software automatically chooses the graphic
  11. gamlj –  general linear model, linear mixed model, generalized linear models, etc.
  12. jamm – advanced mediation analysis (similar to the popular Process Macro for SAS and SPSS)
  13. jjstatsplot – a wrapper for ggstatsplot
  14. jmvbaseR – t-tests, ANOVA, correlation, and regression done using classic R functions rather than the newer ones in the jmv package
  15. jmvR – makes analyses from R’s stats package usable from jamovi to help people learn basic R commands
  16. jpower – power analysis for common research designs
  17. jsq – Bayesian methods including t-tests, ANOVAs, linear models, and contingency tables
  18. jsurvival – survivla module of ClinicoPath
  19. lsj-data – example data sets to accompany the book learning statistics with jamovi
  20. MAJOR – meta-analysis based on R’s metafor package
  21. MEDA – multivariate exploratory data analysis (correspondence analysis via FactoMineR)
  22. meddecide – functions for inter-observer and intra-observer reliability and decision test (e.g. sensitivity, specificity, PPV, NPV)
  23. medmod – basic mediation and moderation analysis
  24. moretests – adds more normality and homogeneity of variance tests
  25. pathj – path analysis
  26. psychoPDA – Psychometrics & post-data analysis
  27. QM – analysis of data from Q-methodology
  28. r-datasets – adds the standard example datasets that come with R
  29. Randomizer – generate various randomized experimental designs (e.g. randomized complete block)
  30. Rj – editor to run R code inside jamovi
  31. rosetta – parallel use of statistical packages in teaching
  32. scatr – scatter plots with marginal density, box plots, & pareto charts
  33. SEDA – Sensory Evaluation Data Analysis for perception data (via SensoMineR)
  34. semlg – structural equation modeling based on lavaan
  35. seolmatrix – correlations suite (e.g. tetrachoric, polychoric, intraclass, partial…)
  36. SimplyAgree – flexible and robust agreement and reliability analyses
  37. snowCluster – k-means, hierarchical, plus visualization
  38. snowIRT – Item Response Theory
  39. snowRMM – Rasch Mixture Model
  40. Statkat – helps you choose a statistical test
  41. surveymv – survey plots
  42. TOSTER – tests of equivalence for t-tests and correlation
  43. ufs – tools for confidence intervals for effect sizes from R’s ufs package
  44. walrus – robust descriptive stats & tests
  45. ztestvis – one-sample z-test
  46. jamovi Arcade – hangman & blackjack games


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 to not 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.

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 window (Figure 2) will slide open from the top with settings for 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, but given that some jamovi users may wish to learn R code, I find that choice puzzling. Changing variable settings can be done to 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 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 variables or observations is as simple as scrolling beyond the set’s current limits and entering additional data. jamovi does not require “add more” buttons as 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:

  • Comma Separated Values (.csv)
  • Plain text files (.txt)
  • SPSS (.sav, .zsav, .por)
  • SAS binary files (.sas7bdat, .xpt)
  • Stata (.dta)
  • JASP (.jasp)

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 commonly a team effort, and in my experience, it’s rare to have all team members prefer to use 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.

A fairly unique feature of jamovi is that it doesn’t save just a dataset, but instead it saves the combination of a dataset plus its associated analyses. To save just the dataset, you use the menu (a.k.a. hamburger) menu to select “Export” then “Data.”  The export formats supported are the same as those provided for import, except for the more rarely-used ones such as SAS xpt and SPSS por and zsav:

  • Comma Separated Values (.csv)
  • Plain text files (.txt)
  • SPSS (.sav)
  • SAS binary files (.sas7bdat)
  • 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).

A critically important 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 it was by double-clicking its name. However, the R code for the transformation is not available, even in with Syntax Mode turned on.

For stacking datasets with common variables, jamovi has one of the easiest approaches I’ve ever seen. With other GUIs you would open one data set, 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. However, jamovi can’t sort, merge, aggregate, transpose, or reshape datasets.

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 non-standard menus that are unique to it and hence require more learning.

jamovi uses standard menu choices for running steps listed on the Data and Analyses tabs. Dialog boxes appear and you select variables to place into their various roles. This is accomplished by either dragging the variable names or by selecting them and clicking an arrow located next to the particular role box. A unique feature of jamovi is that as soon as you fill in enough options to perform an analysis, its output appears instantly. There is no “OK” or “Run” button as the other GUIs reviewed here have. Thereafter, 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 have the dialog box 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 be aware that R is doing the work in the background.

Output is saved by 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.


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 that is the R Commander, which lacks help on the dialog boxes themselves.

jamovi doesn’t offer any 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 that 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 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 never was able to find any help on that function. Hopefully, this situation will improve as jamovi matures.


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 quite a lot 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. Many of its plug-in modules also provide plots, which are not listed here.

  1. Analyses> Factor Analysis – Scree Plot
  2. Exploration> Descriptives – Bar Plot
  3. Exploration> Descriptives – Box Plot
  4. Exploration> Descriptives – Density
  5. Exploration> Descriptives – Histogram
  6. Exploration> Descriptives – QQ Plot
  7. Exploration> Descriptives – Strip Plot (called “Data”)
  8. Exploration> Descriptives – Violin Plot
  9. Exploration> scatr – Scatter Plot
  10. Exploration> scatr – Pareto Chart
  11. Exploration> scatr – Scatter with fit lines
  12. Exploration> scatr – Scatter with marginal density
  13. Exploration> scatr – Scatter with a marginal box plot

Let’s take a look at how jamovi does scatterplots. I used the menu, “Analyses> Exploration> Plots> Scatterplot” and filled in the variables for x- and y-axes, the group variable gender, the regression line “linear” and then I checked the “Standard error” 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, since jamovi uses its own functions fairly exclusively, it generated the following code. Note that unless you activated “Syntax Mode” under the triple-dot menu, you would not see any code at all.

    data = data,
    x = "pretest",
    y = "posttest",
    group = "gender",
    line = "linear",
    se = TRUE)

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 was this:

  data = data,
  out = posttest,
  preds = pretest,
  given = vars(gender, workshop),
  line = "Regression",
  ghost = FALSE,
  JITTX = 0)

This follows the usual jamovi style of being easier to read than the usual R code that one would use to create the plot.

The ability to create small multiple plots is not comprehensive, however. Since flexplot revolves around statistical modeling, there is currently no way to create small multiples of bar plots, boxplots, or violin plots. jamovi also lacks the ability to create large multiple plots, which simply reproduce the entire full-sized plot by one or more grouping factors. BlueSky Statistics is the only package reviewed in this series that has that ability.


The way statistical models (which R stores in “model objects”) are created and used, is an area on which R GUIs differ the most. The simplest and least flexible approach is taken by RKWard. It tries to do everything you might need in a single dialog box. To an R programmer, that sounds extreme, 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.

Other GUIs, such as BlueSky and R Commander save models, allowing to use them 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 simplest approach. It does not save models, so there is no way to apply models to new data sets, or even to a hold-out sample to see how effectively the model generalizes. Instead, it tries to anticipate your needs, providing things like normal probability plots for residuals. This is great for intro statistics courses, but it lacks the flexibility that more advanced researchers prefer.

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 table below, jamovi offers the basics of statistical analysis. In order to make this list more comparable to other R GUIs, I’m including analyses from the Plug-in Modules for Bayesian statistics (same as those in JASP) and distributions (to be comparable to the R Commander and BlueSky Statistics). See Plug-in Modules section above for more analysis types.

  1. Exploration: Frequencies
  2. Exploration: Descriptives
  3. Independent Samples T-Test
  4. Bayesian Independent Samples T-Test
  5. Paired Samples T-Test
  6. Bayesian Paired Samples T-Test
  7. One Sample T-Test
  8. Bayesian One Sample T-Test
  9. ANOVA
  10. Bayesian ANOVA
  11. One-Way ANOVA
  12. ANOVA
  13. Bayesian ANOVA
  14. Repeated Measures ANOVA
  15. Bayesian Repeated Measures ANOVA
  16. ANCOVA
  17. Bayesian ANCOVA
  19. One-Way ANOVA (Non-parametric)
  20. Repeated Measures ANOVA (Non-parametric)
  21. Correlation Matrix
  22. Partial Correlation
  23. Bayesian Correlation Matrix
  24. Linear Regression
  25. Bayesian Linear Regression
  26. Logistic Regression (2 Outcomes)
  27. Logistic Regression (N Outcomes)
  28. Logistic Regression (Ordinal Outcomes)
  29. Proportion Test (2 Outcomes)
  30. Bayesian Proportion Test (2 Outcomes)
  31. Proportion Test (N Outcomes)
  32. Contingency Tables, Independent
  33. Contingency Tables, Paired
  34. Log-Linear Regression
  35. Bayesian Log-Linear Regression
  36. Reliability Analysis
  37. Principal Component Analysis
  38. Exploratory Factor Analysis
  39. Confirmatory Factor Analysis
  40. distrACTION: Normal Distribution
  41. distrACTION: T-Distribution
  42. distrACTION: Chi-squared Distribution
  43. distrACTION: Binomial Distribution

Generated R Code

One of the aspects that most differentiates 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:

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

An R user who is 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.

jamovi’s main mission is to make their point-and-click GUI comprehensive. However, it does offer a plug-in module 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 report 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 to have reproducibility in the form they prefer.

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. 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 that has the same variables.

If you wish to share your work with a colleague, and they’re jamovi users, you need only your jamovi workspace file. It contains everything they need in a single file. This includes the dataset used (only one is possible). 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. However, this title cannot be changed. So if you perform several of the same type of analysis in a row, it’s hard to tell them apart. Also, there is no way to add comments or notes in the output.

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 an ability to select a subset 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.

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, for 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 our 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!)

BlueSky is the only R GUI reviewed here that does all three levels of output management. jamovi not only lacks these three levels of output management, it even lacks the fundamental observation-level saving that SAS and SPSS offered in their first versions back in the early 1970s. This entails saving predicted values or residuals from regression, scores from principal components analysis, or factor analysis. I hope that these basics are added to a future version of jamovi soon.

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.


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 clearly, they have 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 re-usable without having to save code. Another particular strength to note is jamovi’s support of Bayesian analysis (borrowed from JASP).

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, though 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.

As nice as jamovi is, it lacks important features, including the ability to see and save data management code; the ability to handle date/time variables; the ability to perform many more fundamental data management tasks; the ability to save new variables such as factor scores; 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.


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.