# Main Dependencies for the Kaneo Repository: Complete Tech Stack Guide

> Explore the main dependencies of the usekaneo kaneo repository. Discover the tech stack including Hono, React 19, Drizzle ORM, Turbo, Better Auth, and Tailwind CSS.

- Repository: [kaneo.app/kaneo](https://github.com/usekaneo/kaneo)
- Tags: tech-stack-guide
- Published: 2026-08-08

---

**The Kaneo repository is a pnpm monorepo built with Hono for the backend API, React 19 with TanStack Query for the frontend, and Drizzle ORM for database operations, managed within a Turbo-powered workspace using Better Auth for security and Tailwind CSS v4 for styling.**

The **kaneo** repository (available at `usekaneo/kaneo`) is an open-source project that organizes its codebase as a pnpm workspace. Understanding the **main dependencies for the kaneo repository** requires examining the [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) files distributed across the backend API, React frontend, and shared internal packages.

## Backend API Dependencies

The backend service, defined in [`apps/api/package.json`](https://github.com/usekaneo/kaneo/blob/main/apps/api/package.json), relies on a minimal, high-performance stack designed for Edge compatibility and type safety.

### Hono Web Framework and Routing

The API is built on **@honojs/hono**, a lightweight web framework that provides the core HTTP server functionality. This is supplemented by **hono-openapi**, which supplies OpenAPI decorators for automatic route documentation generation. The combination creates a fast, documented API surface with minimal overhead.

### Database and Authentication

Data persistence relies on **drizzle-orm**, a type-safe PostgreSQL ORM that allows SQL-like queries in TypeScript. Authentication and session management are handled by **better-auth**, which integrates with the ORM layer. For validation, the API uses **valibot** alongside Zod for schema definition and input sanitization.

### Utility Libraries

Unique identifier generation is handled by **@paralleldrive/cuid2**, providing collision-resistant CUIDs for database records. These utilities are imported throughout the API source files to ensure consistent data handling.

```typescript
import { Hono } from "hono";
import { validator } from "hono-openapi";
import * as v from "valibot";
import { db } from "./db";
import { projects } from "./schema";

const app = new Hono()
  .get(
    "/projects/:id",
    validator("param", v.object({ id: v.string() })),
    async (c) => {
      const { id } = c.req.valid("param");
      const project = await db.select().from(projects).where(eq(projects.id, id));
      return c.json(project);
    },
  );

export default app;

```

## Frontend Web Dependencies

The web application, located in [`apps/web/package.json`](https://github.com/usekaneo/kaneo/blob/main/apps/web/package.json), utilizes a modern React 19 stack focused on performance and developer experience.

### Core React Ecosystem

The UI is powered by **react** version 19 and **react-dom** for rendering. Routing is implemented via **@tanstack/router**, which provides file-based routing conventions similar to modern meta-frameworks.

### State and Data Management

Server state synchronization is handled by **@tanstack/react-query**, which manages caching, background updates, and data fetching. For global client-side state, the application uses **zustand**, a lightweight state management solution that avoids the boilerplate of larger alternatives.

### UI Components and Styling

Interface components are built using **radix-ui** primitives, providing unstyled, accessible building blocks that comply with WAI-ARIA standards. Styling is implemented with **tailwindcss** version 4, utilizing its utility-first approach for rapid UI development.

```typescript
import { useQuery } from "@tanstack/react-query";
import { getProject } from "@/fetchers/project";

export function useProject(id: string) {
  return useQuery({
    queryKey: ["project", id],
    queryFn: () => getProject(id),
    staleTime: 5 * 60_000,
  });
}

```

```tsx
export function Card({ children }: { children: React.ReactNode }) {
  return (
    <div className="rounded-lg bg-white shadow-md p-4 hover:shadow-lg transition-shadow">
      {children}
    </div>
  );
}

```

## Shared Workspace Packages

The monorepo structure includes internal packages that share code between the API and web layers:

- **@kaneo/libs**: Core utilities defined in [`packages/libs/package.json`](https://github.com/usekaneo/kaneo/blob/main/packages/libs/package.json) and consumed by both frontend and backend
- **@kaneo/email**: Email helper utilities for transactional notifications
- **@kaneo/permissions**: Centralized permission logic for access control

These packages are referenced in the root [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) workspace configuration and imported using TypeScript path mapping to eliminate code duplication across the repository.

## Development and Build Tooling

The repository workflow is orchestrated by several critical dev dependencies:

- **pnpm**: The workspace-aware package manager configured via [`pnpm-workspace.yaml`](https://github.com/usekaneo/kaneo/blob/main/pnpm-workspace.yaml) to link `apps/*` and `packages/*`
- **turbo**: A high-performance task runner that caches build outputs across the monorepo
- **biome**: A unified linter and formatter that replaces ESLint and Prettier
- **vitest**: The test runner for both unit and integration testing

These tools ensure consistent code quality and fast build times across the entire workspace, from the API in `apps/api/` to the web interface in `apps/web/`.

## Summary

- The **kaneo** repository organizes code as a **pnpm monorepo** with dedicated workspaces for the API, web frontend, and shared libraries.
- **Backend dependencies** center on **Hono** for the HTTP framework, **Drizzle ORM** for database operations, and **Better Auth** for security.
- **Frontend dependencies** include **React 19**, **TanStack Query** for server state, **Zustand** for client state, and **Tailwind CSS v4** for styling.
- **Shared packages** (`@kaneo/libs`, `@kaneo/email`, `@kaneo/permissions`) provide centralized utilities referenced in both [`apps/api/package.json`](https://github.com/usekaneo/kaneo/blob/main/apps/api/package.json) and [`apps/web/package.json`](https://github.com/usekaneo/kaneo/blob/main/apps/web/package.json).
- **Development tooling** leverages **pnpm**, **Turbo**, **Biome**, and **Vitest** for monorepo task running and code quality.

## Frequently Asked Questions

### What package manager does the kaneo repository use?

The kaneo repository uses **pnpm** as its package manager, configured as a monorepo via [`pnpm-workspace.yaml`](https://github.com/usekaneo/kaneo/blob/main/pnpm-workspace.yaml). This setup defines workspace packages in `apps/*` and `packages/*`, enabling efficient dependency deduplication and cross-package imports between the API and frontend.

### How does the kaneo backend handle database operations?

The backend uses **drizzle-orm** for type-safe PostgreSQL interactions, as specified in [`apps/api/package.json`](https://github.com/usekaneo/kaneo/blob/main/apps/api/package.json). This ORM allows the API to write SQL-like queries in TypeScript with compile-time type safety, working alongside **@paralleldrive/cuid2** for generating unique identifiers.

### Why does the kaneo frontend use both TanStack Query and Zustand?

**@tanstack/react-query** manages server-state synchronization, caching, and background refetching of API data, while **zustand** handles global client-side UI state. This separation follows modern React patterns by keeping remote data logic distinct from local interface state.

### What is the purpose of the hono-openapi dependency?

**hono-openapi** provides decorators and validators that integrate with the Hono framework to generate OpenAPI specifications automatically. This dependency allows the `apps/api` routes to self-document, producing API schemas directly from the TypeScript code and validation logic defined with **valibot**.