# What Programming Languages Are Used in the Macro Repository?

> Discover the programming languages powering the Macro monorepo. Primarily Rust and TypeScript/JavaScript, with Python, TOML, JSON, and Shell for auxiliary tasks.

- Repository: [Macro/macro](https://github.com/macro-inc/macro)
- Tags: getting-started
- Published: 2026-08-20

---

**The Macro monorepo is a polyglot codebase built primarily in Rust and TypeScript/JavaScript, with auxiliary Python scripts and configuration files in TOML, JSON, and Shell.**

The `macro-inc/macro` repository is a monorepo that relies on multiple programming languages to power its backend services, client SDK, and developer tooling. Understanding the programming languages used in the macro repository reveals a clear architectural split: Rust drives performance-critical infrastructure, while TypeScript and JavaScript handle user-facing components.

## Primary Programming Languages in the Macro Repository

The source code is organized around three main languages, each responsible for distinct layers of the stack.

### Rust: High-Performance Backend Services

Rust powers the core backend microservices, including document storage, connection gateways, and email handling. In [`crates/worker-rs-otel/src/lib.rs`](https://github.com/macro-inc/macro/blob/main/crates/worker-rs-otel/src/lib.rs), the Rust source defines telemetry workers that underpin observability across services. A typical service entry point uses `tokio::main` to bootstrap an async runtime, load configuration, and start the application loop.

```rust
#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::load()?;
    let app = App::new(config).await?;
    app.run().await
}

```

According to the macro source code, this pattern appears across multiple crates that share a workspace defined at the repository root.

### TypeScript and JavaScript: Frontend, SDK, and Node Utilities

TypeScript and JavaScript dominate the web client, public SDK, and Node-based tooling. The SDK entry point in [`packages/sdk/src/macro.ts`](https://github.com/macro-inc/macro/blob/main/packages/sdk/src/macro.ts) exports the `MacroClient` class, which consumers use to interact with the platform’s project APIs.

```typescript
import { MacroClient } from "./macro";

export async function listProjects() {
  const client = new MacroClient({ apiKey: process.env.MACRO_API_KEY! });
  const projects = await client.projects.list();
  console.log("Projects:", projects);
}

```

As implemented in `macro-inc/macro`, the TypeScript packages are managed via a root [`package.json`](https://github.com/macro-inc/macro/blob/main/package.json) that coordinates the monorepo’s Node dependencies and build scripts.

### Python: Data Processing and Transcription Helpers

Python appears in targeted data-processing scripts, most notably for audio transcription workflows. The file [`services/transcription/transcriber.py`](https://github.com/macro-inc/macro/blob/main/services/transcription/transcriber.py) implements a utility that loads OpenAI’s Whisper model and converts audio files to text.

```python
import whisper

def transcribe(audio_path: str) -> str:
    model = whisper.load_model("base")
    result = model.transcribe(audio_path)
    return result["text"]

```

This module demonstrates how the macro repository uses Python for specialized machine-learning tasks without making it a dominant runtime in the stack.

## Configuration and Build Languages

Beyond application code, the repository contains several declarative and scripting languages that manage builds, packaging, and CI.

### TOML: Rust Workspace and Manifest Files

The Rust ecosystem in this monorepo is coordinated through [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml), which defines workspace members and shared dependencies across the `crates/` directory.

### JSON and Shell: Node Metadata and CI Orchestration

JSON manifests in [`package.json`](https://github.com/macro-inc/macro/blob/main/package.json) declare Node package metadata, while Shell scripts—such as those found under [`scripts/setup.sh`](https://github.com/macro-inc/macro/blob/main/scripts/setup.sh)—handle environment setup, build orchestration, and deployment pipelines.

## Summary

- **Rust** is the primary backend language in the macro repository, driving microservices via async runtimes in files like [`crates/worker-rs-otel/src/lib.rs`](https://github.com/macro-inc/macro/blob/main/crates/worker-rs-otel/src/lib.rs).
- **TypeScript and JavaScript** power the frontend, SDK ([`packages/sdk/src/macro.ts`](https://github.com/macro-inc/macro/blob/main/packages/sdk/src/macro.ts)), and Node tooling under a unified [`package.json`](https://github.com/macro-inc/macro/blob/main/package.json) workspace.
- **Python** supports auxiliary tasks such as audio transcription in [`services/transcription/transcriber.py`](https://github.com/macro-inc/macro/blob/main/services/transcription/transcriber.py).
- **TOML, JSON, and Shell** files manage Rust crates, Node packages, and CI scripts respectively.

## Frequently Asked Questions

### What is the main programming language used in the Macro repository?

Rust is the dominant language for backend infrastructure, while TypeScript and JavaScript handle the majority of frontend and SDK code. Python is used only for isolated utilities like transcription.

### Where is TypeScript used in the Macro monorepo?

TypeScript is used in [`packages/sdk/src/macro.ts`](https://github.com/macro-inc/macro/blob/main/packages/sdk/src/macro.ts) for the public SDK, as well as across the web client and various Node-based tooling packages. The entire Node ecosystem is managed through a root [`package.json`](https://github.com/macro-inc/macro/blob/main/package.json).

### Does the Macro repository use Python for machine learning?

Yes, Python is employed for targeted machine-learning tasks such as audio transcription. The file [`services/transcription/transcriber.py`](https://github.com/macro-inc/macro/blob/main/services/transcription/transcriber.py) loads the Whisper model to transcribe audio paths into text.

### What build configuration languages are present in the Macro repository?

The repository uses **TOML** for Rust workspace definitions in [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml), **JSON** for Node metadata in [`package.json`](https://github.com/macro-inc/macro/blob/main/package.json), and **Shell** scripts for CI and deployment orchestration.