# Apache Superset Development Tools: Complete Tech Stack and Monorepo Guide

> Explore the Apache Superset tech stack including Bun, Turborepo, TypeScript, React, Next.js, Tailwind CSS, Drizzle ORM, and Neon PostgreSQL. Learn about its monorepo development approach.

- Repository: [Superset/superset](https://github.com/superset-sh/superset)
- Tags: tech-stack-guide
- Published: 2026-03-08

---

**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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/apps/web/next.config.ts) file configures the application to use [`proxy.ts`](https://github.com/superset-sh/superset/blob/main/proxy.ts) instead of legacy middleware patterns, as noted in [`AGENTS.md`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/packages/ui/package.json) (line 21) scaffolds new components:

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

```

Import components throughout the monorepo using:

```tsx
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:

```ts
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:

```bash
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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/apps/desktop/AGENTS.md) (line 37). The [`package.json`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/package.json) (line 25) defines the `test` script that runs unit and integration tests for every package:

```bash
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`](https://github.com/superset-sh/superset/blob/main/.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:

```bash

# 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`](https://github.com/superset-sh/superset/blob/main/packages/email/README.md), line 169):

```ts
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`](https://github.com/superset-sh/superset/blob/main/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`](https://github.com/superset-sh/superset/blob/main/.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`](https://github.com/superset-sh/superset/blob/main/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.