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

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 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:

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 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:

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 defines the build configuration for these isomorphic utilities.

Monorepo Configuration and Workspace Structure

The root 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 – React 19 entry point that initializes the front-end application with TypeScript support.
• server/package.json – Declares NestJS dependencies and TypeScript compilation scripts for the Node.js runtime.
• shared/package.json – Houses shared TypeScript schemas and build configurations used by both client and server.
• Root 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 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, 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 includes NestJS dependencies, and controllers implement the framework's decorator-based architecture to define routes and dependency injection.

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