What Programming Languages Are Used in the Macro Repository?

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, 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.

#[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 exports the MacroClient class, which consumers use to interact with the platform’s project APIs.

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 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 implements a utility that loads OpenAI’s Whisper model and converts audio files to text.

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, which defines workspace members and shared dependencies across the crates/ directory.

JSON and Shell: Node Metadata and CI Orchestration

JSON manifests in package.json declare Node package metadata, while Shell scripts—such as those found under 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.
• TypeScript and JavaScript power the frontend, SDK (packages/sdk/src/macro.ts), and Node tooling under a unified package.json workspace.
• Python supports auxiliary tasks such as audio transcription in 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 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.

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 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, JSON for Node metadata in package.json, and Shell scripts for CI and deployment orchestration.

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