# What Programming Languages Does TREK Use? A Full-Stack TypeScript Breakdown

> Discover what programming languages TREK uses. This full-stack TypeScript breakdown covers React 19 front-end with TSX and a Node.js back-end with NestJS.

- Repository: [Maurice/TREK](https://github.com/mauriceboe/TREK)
- Tags: deep-dive
- Published: 2026-07-10

---

**TREK is built entirely in TypeScript, leveraging TSX for the React 19 front-end and TypeScript with NestJS for the Node.js back-end.**

TREK is a modern full-stack application organized as a TypeScript monorepo. The codebase utilizes a unified language across all layers, with dedicated workspaces for the client, server, and shared utilities. Understanding what programming languages TREK uses reveals a cohesive development environment designed for type safety and scalability.

## Front-End TypeScript and TSX Implementation

The user interface resides in the `client` workspace and is written entirely in **TypeScript/TSX**. The entry point [`client/src/main.tsx`](https://github.com/mauriceboe/TREK/blob/main/client/src/main.tsx) bootstraps a React 19 application, rendering components with strict type checking enabled. This approach ensures that props, state, and event handlers maintain compile-time validation across the entire component tree.

The following example demonstrates a simple React widget written in TSX:

```tsx
import React from 'react';

export const Welcome = () => (
  <div className="p-4 text-center text-lg font-semibold">
    Welcome to TREK!
  </div>
);

```

## Back-End TypeScript with NestJS

The server-side logic lives in the `server` workspace, implemented in **TypeScript** running on Node.js. According to the [`server/package.json`](https://github.com/mauriceboe/TREK/blob/main/server/package.json) manifest, the application uses the NestJS framework to structure controllers and services. The TypeScript runtime enforces type safety for API contracts, database interactions, and business logic.

This NestJS controller example shows the decorator-based architecture used for API endpoints:

```typescript
import { Controller, Get } from '@nestjs/common';

@Controller('health')
export class HealthController {
  @Get()
  check() {
    return { status: 'ok', timestamp: new Date().toISOString() };
  }
}

```

## Shared Workspace: Common TypeScript Utilities

Common types, validation schemas, and utility functions reside in the `shared` workspace, also written in **TypeScript**. This workspace exports reusable code consumed by both the client and server, ensuring data structures remain synchronized across the stack without language barriers. The [`shared/package.json`](https://github.com/mauriceboe/TREK/blob/main/shared/package.json) defines the build configuration for these isomorphic utilities.

## Monorepo Configuration and Workspace Structure

The root [`package.json`](https://github.com/mauriceboe/TREK/blob/main/package.json) defines the three workspaces—`client`, `server`, and `shared`—and enforces consistent dependency versions, including a single React version across the entire codebase. This configuration eliminates version drift and maintains uniform TypeScript compiler options.

Key source files that define the language stack include:

- **[`client/src/main.tsx`](https://github.com/mauriceboe/TREK/blob/main/client/src/main.tsx)** – React 19 entry point that initializes the front-end application with TypeScript support.
- **[`server/package.json`](https://github.com/mauriceboe/TREK/blob/main/server/package.json)** – Declares NestJS dependencies and TypeScript compilation scripts for the Node.js runtime.
- **[`shared/package.json`](https://github.com/mauriceboe/TREK/blob/main/shared/package.json)** – Houses shared TypeScript schemas and build configurations used by both client and server.
- **Root [`package.json`](https://github.com/mauriceboe/TREK/blob/main/package.json)** – Configures the monorepo workspaces and enforces TypeScript/React version overrides.

## Summary

- TREK uses **TypeScript** exclusively across all workspaces, eliminating language context switching.
- The front-end employs **TSX** (TypeScript JSX) with **React 19** to render type-safe components.
- The back-end runs **TypeScript** on Node.js using the **NestJS** framework for structured API development.
- The `shared` workspace provides isomorphic TypeScript utilities consumed by both client and server.
- Workspace configuration in the root [`package.json`](https://github.com/mauriceboe/TREK/blob/main/package.json) ensures consistent language standards and dependency management.

## Frequently Asked Questions

### Is TREK built with JavaScript or TypeScript?

TREK is built entirely with TypeScript. Both the front-end React components and back-end NestJS services use `.ts` and `.tsx` files, providing static type checking and interfaces throughout the application stack.

### What front-end framework does TREK use?

TREK uses **React 19** for the front-end, as declared in the workspace dependencies. The application mounts via [`client/src/main.tsx`](https://github.com/mauriceboe/TREK/blob/main/client/src/main.tsx), which renders the component tree using React with full TypeScript support.

### Does TREK use different programming languages for the client and server?

No. Both the `client` and `server` workspaces use **TypeScript** exclusively. The `shared` workspace further unifies the stack by providing common TypeScript types and utilities consumed by both sides, ensuring type consistency across the network boundary.

### What back-end framework is implemented in TREK?

The back-end uses **NestJS**, a TypeScript-first framework for Node.js. The [`server/package.json`](https://github.com/mauriceboe/TREK/blob/main/server/package.json) includes NestJS dependencies, and controllers implement the framework's decorator-based architecture to define routes and dependency injection.