vaex

Analyze massive tabular datasets with lazy out-of-core Vaex expressions.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/gabrielvuksani/wotann --skill vaex-gabrielvuksani
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: vaex
Source: https://github.com/gabrielvuksani/wotann/tree/main/skills/scientific/vaex
Command: npx skills add https://github.com/gabrielvuksani/wotann --skill vaex-gabrielvuksani

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you process and analyze extremely large tabular datasets that are too big to fit in memory by using lazy, out-of-core computations.

Core Features & Use Cases

  • Out-of-core lazy DataFrames: Build virtual columns and defer computation until results are needed, enabling interactive exploration on massive files.
  • High-performance filtering, aggregations, and groupby: Compute statistics efficiently (optionally in a single pass) using expressions, selections, and binning.
  • Scalable visualization and ML-ready pipelines: Create heatmaps and histograms for big data and prepare features for machine learning with Vaex ML on large datasets.

Use case example: You have a multi-terabyte Parquet dataset and need to compute fast summary statistics and produce a 2D heatmap (e.g., mean of one metric across binned x/y ranges) without loading the entire dataset into RAM.

Quick Start

Use the vaex skill to summarize the dataset in 'data.parquet' by computing grouped statistics and generating a 2D heatmap from columns x and y.

Frequently Asked Questions about vaex

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I analyze a billion-row Parquet dataset without running out of RAM?

You can analyze billion-row tabular datasets without running out of RAM by using out-of-core lazy DataFrames that defer computation. This approach processes large Parquet, CSV, Arrow, and HDF5 files via memory mapping instead of loading them fully into memory.

What is lazy evaluation for big data and how does it help with feature engineering?

Lazy evaluation for big data builds virtual columns and defers computation until results are explicitly needed. This enables feature engineering on massive datasets by avoiding eager memory allocation, allowing interactive exploration on files that exceed available RAM.

Can I generate visualizations like heatmaps directly on terabyte-scale data files?

Yes, scalable visualizations like heatmaps and histograms can be generated directly on terabyte-scale data files. By computing aggregations and binning metrics across lazy expressions, visual exploratory analysis handles massive datasets efficiently without full memory loading.

How do I compute grouped statistics and aggregations on massive CSV files?

Grouped statistics and aggregations on massive CSV files are computed efficiently using out-of-core expressions and selections. High-performance filtering, groupby operations, and single-pass statistics calculation process large datasets without exhausting memory resources.

What are the limitations of out-of-core dataframe processing for big data?

Out-of-core dataframe processing requires deferring computations via lazy evaluation, meaning intermediate results are not immediately materialized. Operations are optimized for scanning large files on disk, so highly iterative or random-access workloads may not achieve the same interactive performance as in-memory processing.