What Programming Languages Does Rowboatlabs/Rowboat Use?

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, 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. Shared Zod schemas for agents and tools are defined in TypeScript to ensure validation consistency across applications:

// 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 handles authentication and chat API calls using standard Python libraries:

# 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 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 for agent schemas and apps/cli/src/tui/ui.tsx for the terminal interface.
• Key Python files include 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 for the Electron renderer and 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 constructs authenticated requests to the chat endpoints defined by the TypeScript backend services, handling JSON serialization and response parsing using Pydantic models.

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