Open Source on DuckDB Lab

Build a SQL Dashboard in 10 Minutes with Shaper: DuckDB's Open-Source Viz Tool

Thu, 14 May 2026 00:00:00 +0000

The Problem: Data Visualization is a Pain

You’ve got your data neatly organized in DuckDB. Your boss wants a dashboard — yesterday.

Your options:

Tableau → $75/user/month. For a 3-person team that’s $2,700/year.
Metabase → Free but heavy. Need a separate server, Java runtime, lots of config.
Python + Plotly → 200+ lines of code for what should be a 5-line query.
Excel charts → 1990 called, they want their workflow back.

What if you could just write SQL and get a chart?

Shaper is exactly that — an open-source, SQL-driven dashboard tool powered by DuckDB under the hood. Write SQL queries with type annotations, and Shaper renders them as bar charts, line charts, pie charts, tables, and more.

GitHub: https://github.com/taleshape-com/shaper (1.1k ⭐, actively maintained)

What is Shaper?

Shaper’s positioning is crystal clear: the DuckDB visualization layer for SQL users.

“As Official says: All in SQL, Powered by DuckDB.”

The core idea: You don’t need to learn any new API or DSL. Just append ::BARCHART, ::XAXIS, etc. to your SQL columns and Shaper figures out how to visualize them.

-- Shaper SQL example
SELECT
 date_trunc('week', created_at)::XAXIS,
 category::CATEGORY,
 count()::BARCHART_STACKED
FROM dataset
GROUP BY ALL ORDER BY ALL;

This SQL produces a stacked bar chart — no JavaScript, no JSON config, no drag-and-drop.

Key Features

Capability	Description
Fully Open Source	MPL-2.0 license, self-hosted
SQL-First	Define charts via SQL type annotations
Git Workflow	Version-control your dashboards
Multi-Source	Query across DuckDB, CSV, Parquet, MySQL, Postgres
White-Label Embed	Embed in iframe or via JS/React SDK without branding
Export	PDF, PNG, CSV, Excel with one click
Scheduled Reports	Auto-generate and deliver reports
Row-Level Security	JWT tokens for data access control

10-Minute Quickstart

Minute 1: Start Shaper

The fastest way to try Shaper is via Docker:

docker run --rm -it -p5454:5454 taleshape/shaper

Open http://localhost:5454 — you’ll see a clean dashboard editor.

No Docker? Shaper also ships as npm and pip packages:

npm install @taleshape/shaper

pip install shaper

Minutes 2-5: Import Data + First Query

Click “New Query” and write your first SQL:

-- See what we're working with
SELECT * FROM read_csv_auto('sales_2024.csv') LIMIT 10;

Shaper uses DuckDB’s engine natively, so all DuckDB features work — read_csv_auto, read_parquet, ATTACH for MySQL/PostgreSQL…

Now for a real chart:

SELECT
 strftime(order_date, '%Y-%m')::XAXIS,
 product_category::CATEGORY,
 SUM(amount)::BARCHART_STACKED
FROM read_csv_auto('sales_2024.csv')
GROUP BY ALL ORDER BY ALL;

Minutes 6-10: Assemble Your Dashboard

Add more queries to build a complete dashboard:

KPI Card:

SELECT
 'Total Revenue'::LABEL,
 '$' || FORMAT('%,.0f', SUM(amount))::VALUE,
 'vs last month ' || CASE WHEN SUM(amount) - LAG(SUM(amount)) OVER () > 0 THEN '↑' ELSE '↓' END || FORMAT('%.1f%%', ABS((SUM(amount) - LAG(SUM(amount)) OVER ()) / LAG(SUM(amount)) OVER () * 100))::SUBTITLE
FROM read_csv_auto('sales_2024.csv');

Trend Line:

SELECT
 order_date::XAXIS,
 SUM(amount)::LINE
FROM read_csv_auto('sales_2024.csv')
GROUP BY ALL ORDER BY ALL;

Top 10 Products:

SELECT
 product_name::LABEL,
 SUM(amount)::BARCHART
FROM read_csv_auto('sales_2024.csv')
GROUP BY ALL ORDER BY SUM(amount) DESC LIMIT 10;

Ten minutes. A 4-component professional dashboard. All SQL. No frontend code.

Advanced Features

4.1 KPI Monitoring & Alerts

Shaper supports scheduled scans that trigger alerts when metrics cross thresholds:

-- Alert if today's sales < $10,000
SELECT
 SUM(amount)::VALUE,
 CASE WHEN SUM(amount) < 10000 THEN '🚨 Below Target'
 ELSE '✅ On Track' END::STATUS
FROM read_csv_auto('sales_2024.csv')
WHERE order_date = CURRENT_DATE;

4.2 Embedded Dashboards

Want to embed dashboards in your product? Shaper supports:

iframe embedding: One line of HTML
JS/React SDK: Full control over styling, no iframe needed
White-label mode: Hide Shaper branding

<!-- iframe embed -->
<iframe src="https://your-shaper.com/d/sales-dashboard"
 width="100%" height="600px"
 frameborder="0"></iframe>

// React SDK approach
import { ShaperDashboard } from '@taleshape/shaper-react';

function App() {
 return <ShaperDashboard dashboardId="sales-dashboard"
 token="your-jwt-token" />;
}

4.3 Scheduled PDF Reports

Configure a cron job to generate PDF reports on schedule:

# Export via CLI
curl -X POST https://your-shaper.com/api/dashboards/sales-weekly/export \
 -H "Authorization: Bearer your-token" \
 -d '{"format": "pdf"}'

When Should You Use Shaper?

Best for:

Teams already using DuckDB for data analysis
SQL analysts who need quick charts
Developers building client-facing dashboards
Backend engineers who want to avoid JavaScript

Not ideal for:

Complex interactive dashboards with drill-down animations
Non-technical users who need drag-and-drop (Shaper is SQL-driven)

Bottom line: If you already use DuckDB, Shaper is the shortest path from query to dashboard to share.

Monetization Ideas

Shaper is free and open-source, but it opens up several business opportunities:

DuckDB + Shaper Dashboard Service: Build data dashboards for SMBs, $300-800/project
Embedded Analytics Module: Integrate Shaper dashboards into your SaaS product
Shaper Training + Templates: Video courses or downloadable dashboard templates
Industry-Specific Dashboard Packs: Pre-built templates for e-commerce, logistics, finance

Summary

Shaper fills the missing visualization layer in the DuckDB ecosystem. It bridges the gap between “querying data with SQL” and “seeing charts that drive decisions” — no new tools, no frontend code, just the SQL you already know.

10 minutes. Zero to a professional dashboard. That’s Shaper’s promise.

Get started now:

docker run --rm -it -p5454:5454 taleshape/shaper

Open http://localhost:5454 and give it a try.

DuckDB Ecosystem Roundup: Top 12 Open Source Projects in May 2026

Wed, 13 May 2026 00:00:00 +0000

Introduction

DuckDB, the embedded columnar OLAP database, is rapidly becoming infrastructure-grade middleware for the data world. In May 2026, the open-source ecosystem built around DuckDB is exploding with innovative projects spanning everything from log management to browser-based analytics.

This article surveys the top 12 DuckDB ecosystem projects currently trending on GitHub, with executable SQL examples for each.

I. Personal Data Management

1. MsgVault ⭐ 1,746 — Lifetime Message Archiving

Author: Wes McKinney (creator of pandas!)

MsgVault archives your lifetime of email and chat messages locally, enabling offline search, analytics, and AI-powered queries — all backed by DuckDB.

Quick Start:

pip install msgvault
msgvault init --email your@gmail.com --slack

Query Examples:

-- Monthly message volume by source
SELECT 
 strftime(date_trunc('month', timestamp), '%Y-%m') AS month,
 source,
 count(*) AS msg_count,
 count(DISTINCT sender) AS unique_senders
FROM messages
WHERE timestamp >= '2025-01-01'
GROUP BY month, source
ORDER BY month DESC;

-- Full-text search for DuckDB discussions
SELECT 
 sender, 
 subject, 
 snippet(body, 30) AS preview,
 timestamp
FROM messages
WHERE body LIKE '%duckdb%'
 OR body LIKE '%DuckDB%'
ORDER BY timestamp DESC
LIMIT 20;

2. DataKit — Browser-Based Data Analysis Studio

DataKit runs entirely in your browser using DuckDB WASM. No data ever leaves your machine.

Supported sources:

Local CSV, Excel, JSON, Parquet files
Amazon S3, Google Sheets, PostgreSQL
MotherDuck (cloud DuckDB)
HuggingFace datasets

SQL Editor Example:

-- Query a CSV file directly from drag-and-drop
SELECT 
 region,
 round(avg(revenue), 2) AS avg_revenue,
 count(*) AS transaction_count,
 sum(revenue) AS total_revenue
FROM 'uploads/sales_2026.csv'
GROUP BY region
ORDER BY total_revenue DESC;

II. Developer Tools

3. dbx ⭐ 1,356 — 15MB Ultra-Lightweight Database Client

Built with Tauri + Vue. At just 15MB, it supports MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, and more.

wget https://github.com/t8y2/dbx/releases/latest/download/dbx-linux-x64
chmod +x dbx-linux-x64
./dbx-linux-x64

Example queries inside dbx:

-- Hello from DuckDB
SELECT 'Hello, DuckDB!' AS greeting;

-- Analyze Parquet files
SELECT 
 date_trunc('month', order_date) AS month,
 category,
 sum(amount) AS sales
FROM 'sales.parquet'
GROUP BY month, category;

4. sqlit ⭐ 4,148 — Terminal Database TUI

Python-based terminal UI supporting MySQL, PostgreSQL, SQLite, DuckDB, CockroachDB, Turso, and more.

pip install sqlit
sqlit duckdb://mydb.duckdb

III. Logging & Operations

5. Sloggo — Minimal Syslog Collector Powered by DuckDB

A lightweight RFC 5424 syslog collector and viewer. Single binary, under 10MB compressed.

docker run --name sloggo \
 -p 5514:5514/udp -p 6514:6514 -p 8080:8080 \
 -e SLOGGO_LISTENERS=tcp,udp \
 -v ./data:/app/.duckdb \
 ghcr.io/phare/sloggo:latest

Send test logs:

echo "<34>1 2026-05-13T10:00:00Z myhost sloggo - - - Hello, Sloggo" | nc localhost 6514

Query persisted logs directly via DuckDB:

-- Sloggo automatically persists logs into DuckDB
SELECT 
 facility,
 severity,
 hostname,
 app_name,
 message,
 timestamp
FROM 'sloggo.duckdb'.logs
WHERE severity = 'error'
 AND timestamp >= now() - INTERVAL '1 hour'
ORDER BY timestamp DESC;

6. arc ⭐ 591 — High-Performance Analytical Database

DuckDB SQL engine + Parquet storage + Arrow format. Single Go binary deployment.

Ingestion: 19.9M records/sec
Queries: 8.4M+ rows/sec

./arc server --data-dir ./data

Example:

CREATE TABLE events AS 
SELECT * FROM read_parquet('events/*.parquet');

SELECT 
 date_trunc('hour', timestamp) AS hour,
 event_type,
 count(*) AS count
FROM events
GROUP BY hour, event_type
ORDER BY hour;

IV. Data Analysis & Visualization

7. Shaper ⭐ 1,121 — SQL-Driven Data Visualization

“Visualize and share your data. All in SQL. Powered by DuckDB.”

-- Sample Shaper query
SELECT 
 category,
 sum(revenue) AS total_revenue,
 count(DISTINCT customer_id) AS unique_customers,
 round(sum(revenue) / count(DISTINCT customer_id), 2) AS revenue_per_customer
FROM orders
JOIN customers USING (customer_id)
GROUP BY category
ORDER BY total_revenue DESC;

8. ChunkHound ⭐ 1,255 — Local-First Codebase Intelligence

Semantic search and RAG for codebases, powered by DuckDB. Supports MCP Server protocol.

docker run -p 8080:8080 chunkhound/chunkhound:latest

Query example:

-- ChunkHound indexes code blocks in DuckDB
SELECT 
 file_path,
 language,
 chunk_type,
 snippet
FROM code_chunks
WHERE content LIKE '%DuckDB%'
 OR content LIKE '%duckdb%'
ORDER BY file_path;

V. Industry Vertical Applications

9. Open-Dronelog ⭐ 1,382 — Drone Flight Log Analyzer

Built with Tauri v2 + DuckDB + React.

SELECT 
 drone_model,
 count(*) AS flight_count,
 round(avg(flight_duration_minutes), 1) AS avg_duration,
 round(max(altitude_meters), 1) AS max_altitude,
 round(avg(battery_consumption_percent), 1) AS avg_battery_use
FROM flight_logs
WHERE flight_date >= '2026-01-01'
GROUP BY drone_model
ORDER BY flight_count DESC;

10. quickq — Health & Epidemiology Questionnaire Toolkit

Author in YAML, deliver via FHIR, analyze via DuckDB. Portable .db file as the study artifact.

# questionnaire.yaml
title: "Sleep Quality Survey"
questions:
 - id: q1
 text: "Average sleep hours in the past week"
 type: number
 - id: q2
 text: "Difficulty falling asleep (1-5)"
 type: scale
 min: 1
 max: 5

-- Analyze survey results
SELECT 
 round(avg(q1_value), 1) AS avg_sleep_hours,
 round(avg(q2_value), 1) AS avg_difficulty_score,
 count(*) AS respondents
FROM questionnaire_responses
WHERE survey_date >= '2026-04-01';

VI. Database Infrastructure

11. OpenDuck ⭐ 536 — Distributed DuckDB

Dual execution model and differential storage, bringing DuckDB to distributed environments.

git clone https://github.com/CITGuru/openduck.git
cd openduck
make build

12. SlothDB ⭐ 832 — Embedded SQL Everywhere

“Built from scratch. Up to 5x faster where it counts.” A C++ embedded SQL database that runs on laptop, server, and in the browser.

Comparison Table

Project	Stars	Language	Core Use Case	DuckDB Role
sqlit	4,148	Python	Terminal DB Management	Query Engine
MsgVault	1,746	Go	Message Archiving	Storage & Query
Open-Dronelog	1,382	TypeScript	Drone Log Analysis	Analytics Engine
dbx	1,356	Vue/Tauri	DB Client	Connection Target
ChunkHound	1,255	Python	Codebase Intelligence	Vector & Semantic Search
Shaper	1,121	Go	SQL Visualization	Query & Rendering
SlothDB	832	C++	Embedded SQL	Reference Implementation
DataKit	—	TypeScript	Browser Analytics	WASM Engine
arc	591	Go	High-Performance Analytics	SQL Engine Core
OpenDuck	536	C++	Distributed Database	Fork Extension
serenedb	468	C++	Real-Time Search Analytics	Storage Engine
Sloggo	—	Go	Syslog Collection	Log Persistence

Traditional Tools Comparison

Scenario	Traditional Approach	DuckDB Approach	Advantage
Log Management	ELK Stack (ES+Logstash+Kibana)	Sloggo + DuckDB	90% less resource, instant deploy
DB Client	DBeaver (500MB)	dbx (15MB)	97% smaller footprint
Code Search	Elasticsearch cluster	ChunkHound + DuckDB	No cluster, local-first
Data Analysis	Jupyter + Pandas	DataKit + DuckDB WASM	Zero install, browser native
Message Archiving	Commercial SaaS	MsgVault + DuckDB	Fully private, permanent storage
Visualization	Tableau/PowerBI	Shaper + DuckDB	Pure SQL, no ETL needed

Monetization Recommendations

Consulting & Training: Offer enterprise integration consulting for DuckDB ecosystem tools — especially private deployments of MsgVault and DataKit
SaaS Platform: Build a managed DuckDB analytics platform based on Shaper or arc, charging by data volume or query count
Industry Verticals: Replicate the Open-Dronelog model for other domains (fleet GPS analytics, agricultural equipment monitoring, IoT sensor data)
Plugin Marketplace: Develop paid plugins for dbx and sqlit (enterprise SSO, audit logging, advanced visualization)
Migration Services: Help enterprises migrate from ELK/Datadog to Sloggo + DuckDB, charging by data volume migrated
Training Courses: Create video courses and bootcamps covering the DuckDB ecosystem tools
Sponsorship Program: Sponsor active OSS projects (Shaper, ChunkHound, etc.) for brand visibility and priority support access

Conclusion

The Docker of data — that’s how many are describing DuckDB’s role in the analytics ecosystem in 2026. The ecosystem has evolved from a single embedded database into a full-stack platform covering log management, data analysis, visualization, developer tooling, and industry-specific applications.

Whether you’re an individual developer or an enterprise team, there’s a DuckDB-powered tool waiting for your use case. These projects prove that DuckDB — the “SQLite for analytics” — is fundamentally reshaping how data tools are built and composed.