Getting Started with artaverse • artaverse

What is artaverse?

artaverse is the meta-package for the Artalytics platform. It serves as the umbrella package that makes it easy to install and use the complete Artalytics ecosystem in a single step.

Similar to how tidyverse packages the tidyverse ecosystem, artaverse provides:

One-step installation of all core Artalytics packages
Convenient loading of core packages with a single library() call
Package discovery functions to explore the ecosystem
Version checking to ensure compatibility

Core vs Extended Packages

The Artalytics ecosystem is divided into two categories:

Core Packages

Core packages are essential for the platform to function. They are automatically installed and attached when you use artaverse.

Core packages include:

Foundation (platform/core/)
- artcore: Low-level platform functions (database, CDN)
- artutils: High-level utilities and data access
- artauth: User authentication and access control
Application (platform/app/)
- artshiny: Shared UI components
- appPlatform: The main Shiny application
Modules (platform/app/)
- modArtist: Artist profile and entry point
- modBrowse: Browse artworks and collections
- modGallery: Digital gallery experiences
- modUpload: Upload and manage artwork projects
- modFrames: Artwork creation analytics

Extended Packages

Extended packages provide additional functionality but are optional. They can be installed individually as needed.

Extended packages include:

Development Tools (platform/misc/)
- arthelpers: Internal development toolkit
Pipelines & Analytics (platform/tool/)
- artpipelines: Data pipeline tools
- artbenchmark: Artwork benchmarking tools
- artcurator: AI chatbot integration
API Integrations (platform/api/)
- artopenai: OpenAI API integration
- artgemini: Google Gemini API integration
- artopensea: OpenSea marketplace integration
- artsend: Resend email API integration

Installation

Install the complete Artalytics platform with one command:

# Using pak (recommended)
pak::pkg_install("artalytics/artaverse")

What Gets Installed

A fresh installation of artaverse installs approximately 180+ packages total:

Category	Count	Description
Artalytics packages	18	Core platform + modules from GitHub
CRAN dependencies	~160	shiny, ggplot2, data.table, httr2, and more
Base R	1	Already included with R

The Artalytics packages installed include:

Core (10 packages): artcore, artutils, artauth, artshiny, appPlatform, modArtist, modBrowse, modGallery, modUpload, modFrames
Extended (8 packages): Available in Suggests for optional installation

Installation typically takes 5-10 minutes on a fresh R environment, depending on your internet connection and system.

Programmatic Installation

You can also use the install_artaverse() function:

# After artaverse is installed, use it to reinstall or add extended packages
library(artaverse)

# Install core packages only (default)
install_artaverse()

# Install core + extended packages
install_artaverse(include_extended = TRUE)

This will install:

The artaverse package itself
All core Artalytics packages
All required dependencies

Extended packages are marked as “Suggests” and can be installed optionally.

Loading Packages

For interactive work, load all core packages at once:

library(artaverse)

This will:

Attach all core Artalytics packages
Display a startup message showing:
- Which packages were loaded
- Their versions
- Any conflicts or issues

The startup message helps you verify that your environment is properly configured.

Discovering Packages

artaverse provides several functions to explore the ecosystem:

List All Packages

# Get a structured list of all packages
packages <- artaverse_packages()
names(packages)
#> [1] "core"     "extended"

# Core packages
packages$core

# Extended packages
packages$extended

Get Core Packages

# Just the core package names
artaverse_core()

Get Extended Packages

# Just the extended package names
artaverse_extended()

Check Installed Versions

# See versions of all installed Artalytics packages
artaverse_versions()

# See only core packages
artaverse_versions(include_extended = FALSE)

This returns a data.table with columns:

package: Package name
version: Installed version (or NA if not installed)
category: “core” or “extended”

Usage Scenarios

Interactive Development

Recommended - Load all core packages for interactive work:

library(artaverse)

# Now all core functions are available
# artcore::..., artutils::..., etc.

Notebooks and Examples

Recommended - Use in R Markdown/Quarto documents:

library(artaverse)

# Demonstrate platform features
# Create visualizations
# Run analyses

Environment Bootstrapping

Recommended - Set up a fresh development environment:

# Install everything
pak::pkg_install("artalytics/artaverse")

# Load and verify
library(artaverse)
artaverse_versions()

Demo Applications

Recommended - Quickly load the platform for demos:

library(artaverse)
# Run demo code

What NOT to Do

Do NOT Use as a Package Dependency

artaverse should NEVER appear in another package’s DESCRIPTION file.

# WRONG - Do not do this in other Artalytics packages
DESCRIPTION:
  Imports:
    artaverse  # <- NO!

Instead, depend on specific packages:

# CORRECT - Depend on what you actually use
DESCRIPTION:
  Imports:
    artcore,
    artutils,
    modBrowse

Why?

Creates unnecessary transitive dependencies
Makes it harder to track actual dependencies
Violates the principle of depending on what you use
Can cause circular dependency issues

Do NOT Use in Production Packages

artaverse is for interactive use and environment setup, not for building other packages.

Correct Dependency Practice

If you’re building an Artalytics package:

Identify what specific packages/functions you actually use
List only those packages in your DESCRIPTION Imports
Test that your package builds with only those dependencies
Update dependencies as your needs change

For Package Developers

Adding a New Package to artaverse

When a new Artalytics package is created:

Decide the category: Is it core (essential) or extended (optional)?

Update R/packages.R:

# For core packages
artaverse_core <- function() {
  c(
    # ... existing packages ...
    "newPackage"
  )
}

# For extended packages
artaverse_extended <- function() {
  c(
    # ... existing packages ...
    "newPackage"
  )
}

Update DESCRIPTION:
- Core packages → Add to Imports: and Remotes:
- Extended packages → Add to Suggests:
Update documentation:
- README.md
- This vignette
- Function documentation

Test and verify:

devtools::document()
devtools::check()

# Verify the package appears
artaverse_packages()

Removing a Package

If a package is deprecated:

Remove from the appropriate function in R/packages.R
Remove from DESCRIPTION
Update documentation
Consider adding a deprecation note

Testing Changes

Always test that:

The package builds: devtools::check()
Installation works: pak::pkg_install(".")
Loading works: library(artaverse)

Functions return correct results:

artaverse_packages()
artaverse_versions()

Package Architecture

artaverse is intentionally minimal:

No business logic - just coordination
No data - just metadata about packages
No heavy dependencies - only what’s needed for package management
Clear purpose - installation and attachment only

This keeps artaverse lightweight and focused on its role as a meta-package.

Getting Help

Issues: Report problems at https://github.com/artalytics/artaverse/issues
Organization docs: https://github.com/artalytics/.github
Repository guidance: See AGENTS.md in the artaverse repository

Summary

artaverse makes it easy to work with the Artalytics platform:

✅ Use pak::pkg_install("artalytics/artaverse") to install everything
✅ Use library(artaverse) for interactive sessions
✅ Use artaverse_*() functions to explore the ecosystem
❌ Don’t use artaverse as a dependency in other packages
❌ Don’t use artaverse for production package code

Think of artaverse as your entry point to the Artalytics ecosystem, not as a building block for other packages.