# What Is the Primary Programming Language of the usekaneo/kaneo Repository?

> Discover the primary programming language for the usekaneo/kaneo repository. Learn how TypeScript powers its backend and frontend components, compiled to JavaScript for universal compatibility.

- Repository: [kaneo.app/kaneo](https://github.com/usekaneo/kaneo)
- Tags: getting-started
- Published: 2026-08-04

---

**The usekaneo/kaneo repository is written primarily in TypeScript**, with every core component—from backend API routes to React frontend hooks—authored in `.ts` and `.tsx` files compiled to JavaScript.

The **usekaneo/kaneo** project is an open-source monorepo for a project management application. Understanding what programming language powers this codebase matters for contributors evaluating the tech stack and developers studying modern full-stack TypeScript patterns. According to the repository's source code, TypeScript serves as the foundation across all layers: backend services, frontend interfaces, shared libraries, and test suites.

## How TypeScript Is Confirmed as the Primary Language

Two definitive signals establish TypeScript as the dominant language in usekaneo/kaneo:

1. **[`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) dev-dependency declaration** — The root [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) lists `"typescript": "5.8.3"` as a dev-dependency, proving the project compiles from TypeScript to JavaScript.

2. **Ubiquitous `.ts`/`.tsx` file extensions** — Source files throughout the repository use TypeScript extensions, such as [`tests/api/ws/in-memory-broadcast-adapter.test.ts`](https://github.com/usekaneo/kaneo/blob/main/tests/api/ws/in-memory-broadcast-adapter.test.ts) for test suites.

These indicators confirm that TypeScript provides static typing, modern JavaScript features, and a unified developer experience across the entire monorepo.

## TypeScript Architecture by Layer

The repository organizes its TypeScript code into distinct architectural layers, each with clear responsibilities and entry points.

### Monorepo Management with pnpm and TurboRepo

The project uses **pnpm** workspaces and **TurboRepo** to coordinate multiple packages (`@kaneo/api`, `@kaneo/web`, etc.). Build scripts in [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) invoke TypeScript-aware pipelines:

```json
{
  "scripts": {
    "build": "turbo build",
    "dev": "turbo dev"
  }
}

```

### Backend API: Hono and Drizzle ORM in TypeScript

The API layer in `apps/api/src/` is built on **Hono**, a lightweight TypeScript web framework, with **Drizzle ORM** handling PostgreSQL interactions. All route handlers, controllers, and database schemas are pure TypeScript modules.

Key entry point: [`apps/api/src/database/schema.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/api/src/database/schema.ts)

Example Hono route pattern from the codebase:

```typescript
import { Hono } from "hono";
import { validator } from "hono-openapi";
import * as v from "valibot";

const api = new Hono<{ Variables: { userId: string } }>()
  .get(
    "/tasks/:id",
    validator("param", v.object({ id: v.string() })),
    async (c) => {
      const { id } = c.req.valid("param");
      const task = await getTaskById(id);
      return c.json(task);
    },
  );

```

### Frontend Web: React 19+ with TypeScript

The `apps/web/src/` directory contains a React 19 application compiled with Vite. UI components, custom hooks, and TanStack Query integrations are all TypeScript modules.

Key entry point: [`apps/web/src/store/project.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/web/src/store/project.ts)

Example React Query hook pattern:

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

export function useTask(taskId: string) {
  return useQuery({
    queryKey: ["task", taskId],
    queryFn: () => getTask(taskId),
    staleTime: 5 * 60_000,
  });
}

```

### Shared Libraries: TypeScript Utilities

The `@kaneo/libs` package exports reusable TypeScript utilities for both API and web consumption.

Key file: [`packages/libs/src/api-url.ts`](https://github.com/usekaneo/kaneo/blob/main/packages/libs/src/api-url.ts)

### Testing: Vitest TypeScript Test Suites

Unit and integration tests use TypeScript with Vitest for type-safe testing.

Key file: [`tests/api/ws/in-memory-broadcast-adapter.test.ts`](https://github.com/usekaneo/kaneo/blob/main/tests/api/ws/in-memory-broadcast-adapter.test.ts)

## TypeScript Schema Definition Example

The Drizzle ORM schema in [`apps/api/src/database/schema.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/api/src/database/schema.ts) demonstrates TypeScript's role in database modeling:

```typescript
import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
import { createId } from "@paralleldrive/cuid2";

export const taskTable = pgTable("task", {
  id: text("id")
    .primaryKey()
    .default(() => createId()),
  title: text("title").notNull(),
  projectId: text("project_id")
    .notNull()
    .references(() => projectTable.id, { onDelete: "cascade" }),
  createdAt: timestamp("created_at", { mode: "date" })
    .defaultNow()
    .notNull(),
  updatedAt: timestamp("updated_at", { mode: "date" })
    .defaultNow()
    .$onUpdate(() => new Date())
    .notNull(),
});

```

## Key TypeScript Files in usekaneo/kaneo

| File | Role |
|------|------|
| [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) | Declares TypeScript dev-dependency and build scripts |
| [`apps/api/src/database/schema.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/api/src/database/schema.ts) | Central Drizzle ORM schema |
| [`apps/web/src/store/project.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/web/src/store/project.ts) | React state management implementation |
| [`packages/libs/src/api-url.ts`](https://github.com/usekaneo/kaneo/blob/main/packages/libs/src/api-url.ts) | Shared API URL construction utility |
| [`tests/api/ws/in-memory-broadcast-adapter.test.ts`](https://github.com/usekaneo/kaneo/blob/main/tests/api/ws/in-memory-broadcast-adapter.test.ts) | TypeScript test suite sample |

## Summary

- **TypeScript is the primary programming language** of usekaneo/kaneo, confirmed by [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) dependencies and pervasive `.ts`/`.tsx` file usage.
- The monorepo structure uses **pnpm workspaces** and **TurboRepo** for TypeScript compilation orchestration.
- **Every layer is TypeScript-native**: Hono backend, React frontend, shared utilities, and Vitest tests.
- **Version 5.8.3** of TypeScript powers the project's type system and build pipeline.

## Frequently Asked Questions

### Is usekaneo/kaneo a JavaScript or TypeScript project?

usekaneo/kaneo is a TypeScript project. While it compiles to JavaScript for runtime execution, all source code is authored in TypeScript with `.ts` and `.tsx` extensions, and `typescript` is explicitly listed as a dev-dependency in [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json).

### What version of TypeScript does usekaneo/kaneo use?

The repository uses TypeScript **5.8.3**, as declared in the root [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) dev-dependencies. This recent version provides full support for modern type system features and performance optimizations.

### Does usekaneo/kaneo use TypeScript for both frontend and backend?

Yes. The backend API in `apps/api/src/` uses TypeScript with Hono and Drizzle ORM, while the frontend in `apps/web/src/` uses TypeScript with React 19 and TanStack Query. Shared packages in `packages/` are also TypeScript-based.

### Why does usekaneo/kaneo use TypeScript instead of plain JavaScript?

TypeScript provides static type checking that catches errors at compile time, enables better IDE support with autocompletion and refactoring tools, and allows the project to use modern JavaScript features with confidence. The consistent type safety across API contracts, database schemas, and UI components reduces runtime bugs in this full-stack application.