# What Programming Languages Are Used in the Kaneo Project?

> Discover the programming languages powering the usekaneo/kaneo project. Learn how TypeScript dominates the backend and frontend, with supporting JavaScript and documentation.

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

---

**The Kaneo project is built almost entirely with TypeScript, using `.ts` and `.tsx` files for both the backend API and frontend UI, supplemented by minimal JavaScript configuration files and JSON or Markdown documentation.**

The Kaneo repository follows a monorepo architecture managed by TurboRepo that standardizes on TypeScript across the entire stack. When examining what programming languages are used in the Kaneo project, the codebase reveals a pure TypeScript ecosystem with no other compiled languages such as Go, Rust, or Java present.

## TypeScript as the Primary Language

According to the `usekaneo/kaneo` source code, TypeScript dominates every layer of the application. The root [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) lists TypeScript as a dev-dependency and defines scripts including `pnpm typecheck` that invoke the TypeScript compiler across the monorepo. Both the backend API and frontend web UI source files use `.ts` and `.tsx` extensions exclusively, compiling to JavaScript only at runtime or build time.

### Backend API Implementation

The backend application resides in `apps/api/src/` and consists entirely of TypeScript files implementing API routes and business logic. The entry point for workspace functionality at [`apps/api/src/workspace/index.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/api/src/workspace/index.ts) demonstrates the type-safe pattern used throughout the server.

For example, the workspace members controller uses the Hono framework with TypeScript:

```typescript
// apps/api/src/workspace/controllers/get-workspace-members.ts
import { Hono } from "hono";
import { validator } from "hono-openapi";
import * as v from "valibot";

export const getWorkspaceMembers = new Hono()
  .get(
    "/:workspaceId/members",
    validator("param", v.object({ workspaceId: v.string() })),
    async (c) => {
      const { workspaceId } = c.req.valid("param");
      // Business logic would fetch members from the DB here
      return c.json({ workspaceId, members: [] });
    }
  );

```

### Frontend React Components

The frontend UI lives in `apps/web/src/` and uses React with TypeScript JSX (TSX) files. Components such as [`apps/web/src/components/user-avatar.tsx`](https://github.com/usekaneo/kaneo/blob/main/apps/web/src/components/user-avatar.tsx) leverage type definitions for props and state management.

```typescript
// apps/web/src/components/user-avatar.tsx
import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";

export function UserAvatar({ name, src }: { name: string; src?: string }) {
  return (
    <Avatar>
      <AvatarImage src={src} alt={name} />
      <AvatarFallback>{name.charAt(0)}</AvatarFallback>
    </Avatar>
  );
}

```

## Supporting Languages and Configuration

While application logic uses TypeScript exclusively, the repository contains supporting files in other formats:

- **JavaScript**: Configuration and tooling files such as [`commitlint.config.js`](https://github.com/usekaneo/kaneo/blob/main/commitlint.config.js) and [`apps/web/postcss.config.js`](https://github.com/usekaneo/kaneo/blob/main/apps/web/postcss.config.js) use plain JavaScript for build tooling and linting rules.
- **JSON**: The [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) defines dependencies and scripts, while [`tsconfig.json`](https://github.com/usekaneo/kaneo/blob/main/tsconfig.json) files configure the TypeScript compiler options across the monorepo packages.
- **Markdown**: Documentation files provide setup guides and API references.

## Absence of Other Compiled Languages

The Kaneo codebase contains no Go, Rust, Java, Python, or other compiled backend languages. The project maintains a unified JavaScript-based runtime environment where TypeScript source files transpile to JavaScript for execution in Node.js or the browser.

## Summary

- **TypeScript** is the sole programming language for application code in the Kaneo project, covering both backend API (`apps/api/src/`) and frontend UI (`apps/web/src/`).
- **JavaScript** appears only in configuration files like [`commitlint.config.js`](https://github.com/usekaneo/kaneo/blob/main/commitlint.config.js) and [`postcss.config.js`](https://github.com/usekaneo/kaneo/blob/main/postcss.config.js) for build tooling.
- **JSON** manages package definitions in [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) and TypeScript compiler configurations.
- No other compiled languages are used; the stack remains entirely within the TypeScript/JavaScript ecosystem.

## Frequently Asked Questions

### Is Kaneo built with TypeScript or JavaScript?

Kaneo is built primarily with TypeScript. While JavaScript appears in tooling configuration files, all core application logic—including API routes in `apps/api/src/` and React components in `apps/web/src/`—uses TypeScript and TSX files that compile to JavaScript for runtime execution.

### What backend framework does Kaneo use?

As implemented in [`apps/api/src/workspace/controllers/get-workspace-members.ts`](https://github.com/usekaneo/kaneo/blob/main/apps/api/src/workspace/controllers/get-workspace-members.ts), Kaneo uses the **Hono** web framework combined with `hono-openapi` for type-safe request validation and routing, all written in TypeScript.

### Does Kaneo contain any Go, Rust, or Python code?

No. The repository contains no Go, Rust, Java, Python, or other compiled languages. The entire codebase uses TypeScript for application logic and JavaScript/JSON for configuration, simplifying the build pipeline and dependency management.

### Where are the TypeScript configuration files located?

TypeScript configuration is managed at the monorepo root and within individual packages. The root [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) defines the TypeScript dev-dependency and `pnpm typecheck` scripts, while individual [`tsconfig.json`](https://github.com/usekaneo/kaneo/blob/main/tsconfig.json) files in `apps/api` and `apps/web` govern compiler settings for their respective TypeScript codebases.