ggEDA: Interactive Exploratory Data Analysis for High-Dimensional Datasets in R

Exploratory Data Analysis (EDA) remains one of the most critical steps in any data science workflow. Before building predictive models or drawing conclusions, you need to understand the structure, distributions, relationships, and quality issues of your data. The R package ggEDA provides a powerful toolkit for creating interactive visualizations specifically designed for this exploratory phase.

What is ggEDA?

ggEDA is an R package that offers turnkey visualizations for exploratory data analysis of high-dimensional datasets. Released in September 2025, it provides two primary visualization approaches:

1. Parallel coordinate plots for exploring large datasets with mostly quantitative features
2. Stacked one-dimensional visualizations that effectively show missingness and complex categorical relationships in smaller datasets

Both visualization types are fully interactive through the ggiraph package, making it easier to explore patterns and identify data quality issues.

Why ggEDA Matters for Modern Data Analysis

As datasets grow in complexity, traditional EDA approaches struggle. You might have dozens or hundreds of variables, missing data scattered throughout, and complex relationships between categorical and continuous features. Manual inspection becomes impractical, and standard plotting functions require extensive customization.

ggEDA addresses these challenges by:

• Automating plot selection based on variable types
• Handling missing data visualization explicitly
• Providing interactivity out of the box
• Supporting custom tooltips for additional context
• Offering flexible sorting and ordering to reveal patterns

This complements existing EDA workflows in R, working alongside packages like DataExplorer, summarytools, and skimr that focus more on statistical summaries and univariate distributions.

Getting Started: The ggstack Function

The ggstack() function is ggEDA's workhorse for comprehensive dataset visualization. It creates vertically aligned plots for all columns in your data frame, with automatic plot type selection based on variable characteristics.

The syntax in the image above is creating the column plots for the dataset baseballfans, a practice set included in the package.

This creates an interactive visualization showing all variables in the dataset. Below is the graph produced, a stacked visualization.

In the visual, you have columns, each one representing one observation (one person/baseball fan). The rows represent each variable from the dataset, with the categorical variables appearing as colored tiles, while numeric variables are shown as bar charts. Thus, you see bar charts for the age and height variables.

The col_sort parameter arranges the variables, so in this instance, the variables are sorted by the "Glasses" column.

The best feature is being able to hover the cursor over each column. Doing so reveals the ID of the observation and its value. This is particularly convenient when you need the exact value of an observation, especially when the scale for numeric variables makes it difficult to see the differences between observations.

In this example, I have my cursor on one of the datapoints, ID 10, in the Height barplot. Note: you can not see the cursor — I snapped the image from my laptop so the cursor was unintentionally removed — but it will remain there when the textbox appears. Observations in the other variable graphs will be highlighted with a thicker black border.

You can work with a different arrangement of variables to reveal other patterns in the dataset. For example, the baseballfans dataset can be sorted by age to discover another pattern or spot an outlier. Below is the code and the resulting visualization.

The sorted visualization can make some differences stand out. Look at the age variable; you can see an outlier (82 years old) more quickly than when examining the data in a table.

Integration with Existing EDA Workflows

ggEDA is meant to complement EDA tools in R rather than replace them. It is a heatmap-like visualization, where you can view the following information about your dataset:

• Rows, which represent variables
• Columns, which highlight observations (sorted by your specified variable)
• Colors, which match the values of categorical variables, such as the hair colour variable in the baseballfans dataset
• Bar heights indicate values for numeric variables
• Gray areas and "!" that highlight missing data

If you want to see how ggEDA best works, give it a try when faced with either of the following explorations.

1. Statistical summaries: Use skimr::skim() or summarytools::dfSummary() alongside ggEDA for numeric summaries of the datasets you are examining.
2. One-hot encoding preparation: After identifying categorical variables with ggEDA, create dummy variables for modeling.

Optional Parameters

There are some other parameters to adjust the visual. You cna remove a variable — perfect when you have a column of data that is not meant to be numeric, like the year. In the gtcars dataset, car models have a model year, but it is not really a number of comparison, like horsepower or torque.

To remove it, the ignore_column_regex parameter is added to the ggstack() function. You indicate the name of a variable, or several columns, using a c() function.

Here is what the gtcars visual looks like, with the model year column removed.

There is also an option to add a legend, through a ggstack_options function, so you can display a legend for each of the categorical variables. There are a number of parameters. The function can be added to the ggstack() function as a group of parameters. In the syntax below, a legend is added with options for how it appears in the visual, ranging from controlling font size and indicating the position of the legend within the visualization.

Here is the resulting visual. The legend for the categorical variables appears at the top, with each color for each variable of the gtcars dataset (Bdy Style, Drivetrain, and Ctry Origins).

In addition, there are toy datasets to explore in the package —the lazy_birdwatcher dataset and minibeans, a dry beans dataset. Combined with the baseballfans datasets, analysts can explore visual settings.

Limitations and Considerations

There are a few considerations to keep in mind with ggEDA, so that you are not misusing it for certain specific purposes. Most of these address visuals more than calculations.

Not for publication-ready graphics

The functions in the ggEDA package focus on exploration, not final presentation details. For publication graphics, use ggplot2.

Limited to one plot per response

The package is designed for interactive exploration rather than generating multiple plots programmatically. So expect to have a few sets of syntax for the variations of the explored dataset

Memory usage

Interactive visualizations with many observations can be memory-intensive. You can set the interactive parameter to eliminate the feature.

Requires clean-ish data

Extremely messy data may need basic cleaning before visualization works well.

This last point highlights ggEDA's real value — to apply the visualizations when you need to review a data cleaning to see if more steps are needed.

Conclusion

ggEDA adds to the EDA ecosystem of R programming by providing interactive, high-dimensional visualizations that support the data exploratory phase. Its features are particularly valuable for understanding complex datasets before model building.

The package works best when integrated into a broader EDA workflow that includes statistical summaries, data quality checks, and domain knowledge. By revealing patterns in high-dimensional data that might otherwise remain hidden, ggEDA helps ensure you understand your data before making analytical decisions.

For datasets with many variables, mixed types, or complex missing data patterns, the ggEDA package offers a practical solution that balances automation with customization, making thorough exploratory analysis both feasible and insightful.

Resources:

• GitHub: https://github.com/CCICB/ggEDA
• Documentation: https://ccicb.github.io/ggEDA/