# What Programming Languages Does OmniRoute Use? Core Stack Explained

> Discover the core programming languages of OmniRoute. Learn how TypeScript, Node.js, Next.js, React, and Electron power this innovative platform. Understand the tech stack.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: deep-dive
- Published: 2026-07-29

---

**TLDR: OmniRoute is built entirely in TypeScript, running on Node.js 22+ with Next.js 16 powering the web layer, React 19 handling the UI, and Electron providing the cross-platform desktop client.**

The open-source OmniRoute repository (diegosouzapw/OmniRoute) is a modular AI router that relies on a unified TypeScript codebase to deliver its web API, desktop application, and command-line interface. Understanding what programming languages OmniRoute uses reveals a modern, JavaScript-centric architecture that compiles to ES Modules for execution. Every component—from the streaming engine to the prompt compression modules—is authored in TypeScript and targets Node.js version 22 or higher.

## TypeScript as the Sole Primary Language

OmniRoute adopts a **full-stack TypeScript** strategy where all source files use `.ts` or `.tsx` extensions. The project leverages TypeScript 6 features and compiles to JavaScript for the Node.js runtime. This approach ensures type safety across the API layer, streaming handlers, and user interface without introducing polyglot complexity.

### Server-Side Runtime and APIs

The backend implementation resides in `src/app/api/v1/*`, utilizing Next.js 16 App Router conventions. The main entry point at [`src/app/api/v1/chat/completions/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/chat/completions/route.ts) handles OpenAI-compatible requests, validates them with Zod, and forwards them to the streaming engine. Core request processing logic lives in [`open-sse/handlers/chatCore.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/handlers/chatCore.ts), where the **Responses API** transformer and provider executors are implemented in pure TypeScript.

### Desktop Application Layer

For native desktop deployment, OmniRoute uses **Electron**. The entry point at [`electron/main.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/electron/main.ts) boots an embedded Node process that serves the same Next.js application used in the web deployment. This allows the desktop client to reuse the exact TypeScript source code powering the browser version, ensuring feature parity across platforms.

### Command Line Interface

The CLI is implemented as a Node.js executable at `bin/omniroute.mjs`. Generated from the API schema via `scripts/build/generate-cli-api.mjs`, this script exposes routing and debugging commands:

```bash

# Launch the Next.js development server

npm run dev

# List available routing combos via CLI

omniroute list-combos

```

## Data Layer and Native Dependencies

While TypeScript dominates the codebase, OmniRoute selectively incorporates native Node.js modules for performance-critical operations.

### SQLite and Vector Storage

The data layer uses **SQLite** via the native `better-sqlite3` package (optional dependency). Database connections and encryption helpers are centralized in [`src/lib/db/core.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/db/core.ts). For vector operations, the project employs `sqlite-vec` alongside `lowdb` for JSON-based storage, all accessed through TypeScript wrappers.

### Optional Machine Learning Bindings

Specific deployment configurations may include optional native modules like `@tensorflow/tfjs`. These C++-backed dependencies are installed only when required and do not alter the primary TypeScript architecture.

## Web Stack and UI Technologies

The user interface layer combines modern frontend technologies authored in TypeScript:

- **Next.js 16**: Provides the App Router structure under `src/app/`
- **React 19**: Powers component logic and state management via Zustand
- **Tailwind CSS v4**: Handles styling across the application
- **next-intl**: Manages internationalization, with configuration files under `src/app/i18n/`

## Build, Test, and Quality Tooling

The development toolchain remains TypeScript-centric:

- **Compilation**: TypeScript 6 with SWC for fast transpilation
- **Runners**: Support for both `tsx` and `bun` execution environments
- **Testing**: **Vitest** for unit testing, **Playwright** for end-to-end testing, and **Stryker** for mutation testing
- **Linting**: ESLint and Prettier enforce code standards, with Husky managing pre-commit hooks

## Summary

- **Primary Language**: TypeScript (`.ts`/`.tsx`) across web, desktop, and CLI
- **Runtime**: Node.js ≥22 with ES Modules
- **Web Framework**: Next.js 16 App Router with React 19 frontend
- **Desktop**: Electron wrapping the Next.js application
- **Database**: SQLite via native `better-sqlite3` bindings
- **CLI**: Node.js executable generated at `bin/omniroute.mjs`
- **Testing**: Vitest and Playwright for comprehensive coverage

## Frequently Asked Questions

### Is OmniRoute written purely in TypeScript?

Yes. According to the source code in diegosouzapw/OmniRoute, every layer—from the API routes in `src/app/api/v1/` to the streaming engine in `open-sse/handlers/` and the Electron main process—is authored in TypeScript. Optional native dependencies exist for SQLite and ML operations, but all application logic is TypeScript.

### What Node.js version does OmniRoute require?

The project requires **Node.js version 22 or higher**, as declared in [`package.json`](https://github.com/diegosouzapw/OmniRoute/blob/main/package.json). This version baseline ensures compatibility with modern ES Module features and the `undici` HTTP client used throughout the provider integrations.

### Does OmniRoute use any compiled native languages like C++ or Rust?

The core architecture uses TypeScript exclusively, but the project optionally leverages native Node.js modules such as `better-sqlite3` (C++) for database performance and `@tensorflow/tfjs` (C++ bindings) for machine learning. These are optional dependencies installed only when specific features are enabled.

### What framework powers the OmniRoute user interface?

The UI is built with **React 19** and styled using **Tailwind CSS v4**, all served through **Next.js 16**. Electron wraps this web stack to create the desktop application, allowing the TypeScript React components to render natively on Windows, macOS, and Linux.