Apache Superset Development Tools: Complete Tech Stack and Monorepo Guide

Apache Superset development relies on a modern Bun and Turborepo monorepo architecture powered by TypeScript strict mode, React 18, Next.js 16, Tailwind CSS v4, Drizzle ORM with Neon PostgreSQL, and Biome for unified code quality.

The superset-sh/superset repository implements a cutting-edge, unified development environment for Apache Superset applications. This analysis examines the complete development toolkit defined in AGENTS.md and source files throughout the codebase, detailing how each technology enables cross-platform development across web, desktop, and mobile clients.

Core Monorepo Infrastructure

Bun Package Management

The repository uses Bun as its sole package manager and runtime. According to AGENTS.md (line 35), Bun handles dependency installation, script execution (e.g., bun dev, bun test), and powers the entire monorepo workflow. The root package.json defines standard commands that delegate to Bun’s high-performance JavaScript engine.

Turbo Build Orchestration

Turborepo manages build pipelines and task caching across workspaces. As documented in AGENTS.md (line 36), Turbo coordinates builds so that changes in shared packages automatically trigger rebuilds in dependent applications. This ensures that modifying packages/ui rebuilds every app consuming it without manual intervention.

Frontend Development Stack

React 18 and Next.js 16

The web applications leverage React 18 as the core UI library, implemented across all apps/* directories. Next.js 16 (App Router) powers both the main web client and documentation site. The apps/web/next.config.ts file configures the application to use proxy.ts instead of legacy middleware patterns, as noted in AGENTS.md (line 40).

Tailwind CSS v4 and shadcn/ui

Styling relies on Tailwind CSS v4 combined with shadcn/ui components. The packages/ui directory contains reusable primitives generated via npx shadcn@latest. The ui-add script in packages/ui/package.json (line 21) scaffolds new components:

bun ui-add button   # Scaffolds shadcn/button component inside packages/ui

Import components throughout the monorepo using:

import { Button } from "@superset/ui/button";   // Resolves to packages/ui/src/button.tsx

Backend and Database Layer

Drizzle ORM with Neon PostgreSQL

Database interactions use Drizzle ORM with Neon PostgreSQL for type-safe SQL generation. Schema definitions live in packages/db/src/schema, enabling compile-time safety and IDE autocomplete. A typical server-side query implementation looks like:

import { db } from "@superset/db";
import { users } from "@superset/db/schema";

const rows = await db.select().from(users).where(eq(users.id, userId));

Run migrations using the Drizzle CLI:

bunx drizzle-kit generate --name="add_posts_table"

Hono API Framework

The API backend combines Next.js API routes with Hono for custom SDK generation. As detailed in mobile-app-structure-comparison.md (line 403), the Hono-based generator reads OpenAPI definitions from the API package and outputs typed client libraries for web, desktop, and mobile consumers.

Cross-Platform Development

Electron Desktop Client

The desktop application (apps/desktop) uses Electron with TanStack Router (planned), as documented in apps/desktop/AGENTS.md (line 37). The package.json defines entry points and custom scripts like desktop:dev for local development.

React Native Mobile (Expo)

The mobile client (apps/mobile) is built with React Native using Expo, listed under the Apps section in AGENTS.md. This implementation shares the MCP (Multi-Client Protocol) layer with the desktop application, enabling real-time messaging across platforms via code in packages/mcp.

Code Quality and Testing

Biome for Linting and Formatting

Biome enforces consistent style across the entire monorepo, handling both formatting and linting. AGENTS.md (line 39) identifies Biome as the primary code quality tool, configured to run in CI pipelines.

Bun Test Runner

Testing uses Bun test executed through Turbo. The root package.json (line 25) defines the test script that runs unit and integration tests for every package:

bun test        # Runs turbo test across all workspaces

bun run typecheck --filter=@superset/ui   # Type-check single package

CI/CD and Automation

GitHub Actions

Continuous integration relies on GitHub Actions, with workflow definitions in .github/workflows/ci.yml. The pipeline runs Biome linting, TypeScript type-checking, and Bun tests on every pull request, ensuring code quality before merge.

Practical Development Workflow

Start the complete development stack with:

# Install dependencies once at root

bun install

# Start web, API, and docs in parallel via Turbo

bun dev

For email templating, the repository uses @react-email with Tailwind integration (packages/email/README.md, line 169):

import { render } from "@react-email/render";
import { WelcomeEmail } from "@superset/email/templates/welcome";

const html = render(<WelcomeEmail name="Jane" />);
await sendMail({ to: "jane@example.com", html });

Summary

• Bun serves as the package manager and runtime for the entire superset-sh/superset monorepo.
• Turborepo caches and orchestrates builds across web, desktop, mobile, and shared packages.
• TypeScript strict mode provides static typing configured via tooling/typescript/tsconfig.json.
• React 18, Next.js 16, Tailwind CSS v4, and shadcn/ui power the frontend development experience.
• Drizzle ORM with Neon PostgreSQL handles type-safe database operations defined in packages/db.
• Biome enforces code quality standards while Bun test runs the test suite.
• GitHub Actions automate CI/CD pipelines defined in .github/workflows/ci.yml.

Frequently Asked Questions

What package manager does Apache Superset development use?

The superset-sh/superset repository uses Bun exclusively for package management and script execution. As documented in AGENTS.md, Bun handles dependency installation (bun install), development servers (bun dev), and test execution (bun test) with superior performance compared to traditional Node.js package managers.

How does the monorepo handle builds across multiple platforms?

Turborepo manages build orchestration and caching. When you run bun dev, Turbo executes the dev scripts for the web, API, and documentation apps in parallel while respecting the dependency graph. Changes to shared packages like packages/ui automatically invalidate caches and trigger rebuilds in dependent applications without manual configuration.

What database tools are used in Apache Superset development?

The development stack uses Drizzle ORM with Neon PostgreSQL. Drizzle provides type-safe SQL generation with schemas defined in packages/db/src/schema, offering compile-time type checking and IDE autocomplete. The drizzle-kit CLI handles database migrations, while the @superset/db package exports typed database clients for use in Next.js API routes and server components.

How are UI components shared between web and mobile applications?

Reusable UI components live in the packages/ui package and are built with React, Tailwind CSS v4, and shadcn/ui. Components are scaffolded using the bun ui-add command, which generates TypeScript React components in packages/ui/src/. Both the Next.js web app and React Native mobile app import these components, ensuring visual consistency across platforms while maintaining platform-specific rendering implementations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}