# What Programming Languages Does Rowboatlabs/Rowboat Use?

> Discover the primary programming languages powering Rowboat a desktop app and web dashboards. Learn how TypeScript and Python drive its features and SDK.

- Repository: [RowBoat Labs/rowboat](https://github.com/rowboatlabs/rowboat)
- Tags: getting-started
- Published: 2026-02-16

---

**Rowboat is built primarily with TypeScript for its Electron desktop app, Next.js web dashboards, and CLI tooling, while using Python to power its official SDK for API interactions.**

The Rowboat monorepo is a full-stack project that leverages TypeScript as its dominant language across multiple applications and shared libraries, complemented by Python for developer SDK support. Understanding the language distribution helps contributors navigate the codebase and select the appropriate tooling for their use case.

## TypeScript: The Primary Language

TypeScript dominates the Rowboat codebase, driving the Electron-based desktop application, Next.js web interfaces, command-line interface, and shared library packages. The extensive use of `.ts` and `.tsx` files enables strict type safety across the entire frontend and tooling ecosystem.

### Electron Desktop Application

The desktop application uses TypeScript to define the renderer process and main process logic. The entry point for the React-based UI rendered within Electron is located at [`apps/x/apps/renderer/src/main.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/renderer/src/main.tsx), where the TypeScript React components mount to the DOM.

### Next.js Web Dashboards

The web-facing dashboards are built with Next.js and written entirely in TypeScript. These applications share core logic through monorepo packages, ensuring consistent type definitions between the web and desktop variants.

### CLI Tool and Shared Libraries

The Rowboat CLI implements a text-based user interface using Ink (a React-based library for terminal UIs) in [`apps/cli/src/tui/ui.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/cli/src/tui/ui.tsx). Shared Zod schemas for agents and tools are defined in TypeScript to ensure validation consistency across applications:

```typescript
// apps/x/packages/shared/src/agent.ts
export const Agent = z.object({
    name: z.string(),
    provider: z.string().optional(),
    model: z.string().optional(),
    description: z.string().optional(),
    instructions: z.string(),
    tools: z.record(z.string(), ToolAttachment).optional(),
});

```

## Python: The SDK Language

Python serves as the secondary language, exclusively supporting the `python-sdk` package located in `apps/python-sdk/`. This SDK provides a simple HTTP client for interacting with Rowboat's API, making it accessible to Python developers without requiring TypeScript knowledge.

### API Client Implementation

The core client class in [`apps/python-sdk/src/rowboat/client.py`](https://github.com/rowboatlabs/rowboat/blob/main/apps/python-sdk/src/rowboat/client.py) handles authentication and chat API calls using standard Python libraries:

```python

# apps/python-sdk/src/rowboat/client.py

class Client:
    def __init__(self, host: str, projectId: str, apiKey: str) -> None:
        self.base_url = f'{host}/api/v1/{projectId}/chat'
        self.headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {apiKey}'
        }

    def run_turn(self, messages, conversationId=None, mockTools=None):
        """Stateless chat method that handles a single conversation turn"""
        return self._call_api(messages, conversationId, mockTools)

```

### Pydantic Schema Definitions

Complementing the client, the Python SDK uses Pydantic models in [`apps/python-sdk/src/rowboat/schema.py`](https://github.com/rowboatlabs/rowboat/blob/main/apps/python-sdk/src/rowboat/schema.py) to define request and response payloads, providing runtime validation and type hints for Python developers.

## Summary

- **TypeScript** is the primary language, powering the Electron desktop app, Next.js web dashboards, CLI tool, and shared Zod schemas in `apps/x/`.
- **Python** provides the official SDK in `apps/python-sdk/`, offering an HTTP client and Pydantic models for API interaction.
- Key TypeScript files include [`apps/x/packages/shared/src/agent.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/shared/src/agent.ts) for agent schemas and [`apps/cli/src/tui/ui.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/cli/src/tui/ui.tsx) for the terminal interface.
- Key Python files include [`apps/python-sdk/src/rowboat/client.py`](https://github.com/rowboatlabs/rowboat/blob/main/apps/python-sdk/src/rowboat/client.py) for the API client implementation.

## Frequently Asked Questions

### Does Rowboat support other programming languages besides TypeScript and Python?

Currently, the core Rowboat platform is built exclusively with TypeScript and Python. While the Python SDK allows developers to interact with Rowboat APIs using Python, the internal services, desktop application, and web interfaces are all TypeScript-based. There are no official SDKs for languages like Go, Rust, or Java at this time.

### Where is the TypeScript code located in the Rowboat repository?

The TypeScript codebase is primarily located in the `apps/x/` directory, which contains the Electron application, Next.js web apps, CLI tooling, and shared packages. Specific entry points include [`apps/x/apps/renderer/src/main.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/renderer/src/main.tsx) for the Electron renderer and [`apps/cli/src/tui/ui.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/cli/src/tui/ui.tsx) for the command-line interface.

### How does the Python SDK interact with the TypeScript backend?

The Python SDK in `apps/python-sdk/` communicates with the Rowboat backend via HTTP REST API calls. The `Client` class in [`apps/python-sdk/src/rowboat/client.py`](https://github.com/rowboatlabs/rowboat/blob/main/apps/python-sdk/src/rowboat/client.py) constructs authenticated requests to the chat endpoints defined by the TypeScript backend services, handling JSON serialization and response parsing using Pydantic models.