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

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 dev-dependency declaration — The root 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 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 invoke TypeScript-aware pipelines:

{
  "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

Example Hono route pattern from the codebase:

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

Example React Query hook pattern:

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

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

TypeScript Schema Definition Example

The Drizzle ORM schema in apps/api/src/database/schema.ts demonstrates TypeScript's role in database modeling:

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	Declares TypeScript dev-dependency and build scripts
apps/api/src/database/schema.ts	Central Drizzle ORM schema
apps/web/src/store/project.ts	React state management implementation
packages/libs/src/api-url.ts	Shared API URL construction utility
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 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.

What version of TypeScript does usekaneo/kaneo use?

The repository uses TypeScript 5.8.3, as declared in the root 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.

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