# What Programming Languages Does Archify Support? Language Agnostic Architecture Mapping Explained

> Archify maps software architecture for any language, including JavaScript, Python, Go, and Rust. Discover how its language agnostic approach simplifies analysis and understanding.

- Repository: [tt-a1i/archify](https://github.com/tt-a1i/archify)
- Tags: api-reference
- Published: 2026-08-11

---

**Archify is written in JavaScript for Node.js ≥18 and supports architecture mapping for any programming language**, including JavaScript, Python, Go, Rust, and more, because it processes a typed JSON intermediate representation rather than parsing source code directly.

Archify is an open-source architecture visualization tool developed by tt-a1i. Unlike traditional static analysis tools that require language-specific parsers, Archify accepts a **typed JSON IR** (intermediate representation) generated by an LLM. This design decision makes it fundamentally **language-agnostic**—you can feed it architecture descriptions for codebases in virtually any programming language.

## How Archify Achieves Language Agnostic Support

The key insight is in how Archify processes information. Instead of directly parsing source files, it relies on an LLM to generate a structured description of your system's components, relationships, and data flows. This abstraction layer removes any dependency on language-specific AST parsers.

In [`archify/package.json`](https://github.com/tt-a1i/archify/blob/main/archify/package.json), the project declares itself as a JavaScript module with Node engine requirements:

```json
{
  "type": "module",
  "engines": {
    "node": ">=18"
  }
}

```

This confirms Archify itself is a **Node-based JavaScript/ESM tool**, but this only describes what powers the CLI—not what it can analyze.

## Concrete Language Examples in the Repository

The tt-a1i/archify repository includes working demonstrations for at least two languages:

### JavaScript / Node.js

The primary CLI entry point at `archify/bin/archify.mjs` is itself a Node script. The Quick-Start guide in [`README.md`](https://github.com/tt-a1i/archify/blob/main/README.md) shows installation via `npm`/`npx`:

```bash
npx skills add tt-a1i/archify -g

```

The [`examples/web-app.html`](https://github.com/tt-a1i/archify/blob/main/examples/web-app.html) file provides a full-featured demo built on a typical JavaScript web application architecture.

### Python

The MCO showcase in [`experiments/mco-showcase/mco-runtime.html`](https://github.com/tt-a1i/archify/blob/main/experiments/mco-showcase/mco-runtime.html) (lines 4574-4621) visualizes a **Python runtime** ([`runtime/mcp_server.py`](https://github.com/tt-a1i/archify/blob/main/runtime/mcp_server.py)) alongside an npm shim. This proves Archify can successfully map Python projects despite having no Python parser in its core.

## Using Archify With Any Programming Language

Because the tool delegates source understanding to the LLM, you can safely use Archify with:

- **Go** projects
- **Rust** crates
- **Java** / **Kotlin** codebases
- **C/C++** applications
- **Ruby**, **PHP**, **Elixir**, or any other language

The only requirement is that you point the CLI at a codebase the LLM can describe. The analysis command remains identical regardless of target language:

```bash

# JavaScript/Node project

archify bin/archify.mjs analyze ./my-node-project --type architecture

# Python project

archify bin/archify.mjs analyze ./my-python-project --type architecture

# Go, Rust, Java, etc.

archify bin/archify.mjs analyze ./my-go-project --type architecture

```

## Key Implementation Files

| File | Relevance to Language Support |
|------|------------------------------|
| [`archify/package.json`](https://github.com/tt-a1i/archify/blob/main/archify/package.json) | Declares Node engine and JavaScript module type |
| `archify/bin/archify.mjs` | Language-agnostic CLI entry point |
| [`README.md`](https://github.com/tt-a1i/archify/blob/main/README.md) | Documents agent-skill architecture, not parser-based |
| [`examples/web-app.html`](https://github.com/tt-a1i/archify/blob/main/examples/web-app.html) | JavaScript/Node demonstration |
| [`experiments/mco-showcase/mco-runtime.html`](https://github.com/tt-a1i/archify/blob/main/experiments/mco-showcase/mco-runtime.html) | Python runtime visualization proof |

## Summary

- **Archify itself runs on** Node.js ≥18 and is written in JavaScript/ESM
- **Archify can analyze** any programming language because it uses LLM-generated JSON IR rather than direct parsing
- **Verified examples** exist for JavaScript/Node and Python
- **No language-specific parsers** are required in the core tool

## Frequently Asked Questions

### Does Archify use language-specific parsers for each supported programming language?

No. Archify does not implement language-specific parsers in its core. According to the tt-a1i/archify source code, it accepts a typed JSON intermediate representation generated by an LLM, making the analysis pipeline completely language-agnostic.

### Why is Archify written in JavaScript if it supports other languages?

The JavaScript/Node implementation in `archify/bin/archify.mjs` provides the CLI runtime and orchestration layer. This choice enables easy distribution via `npm` and execution with `npx`. The language of the tool itself is independent from the languages it can analyze.

### Can Archify analyze a Go or Rust codebase?

Yes. Since Archify processes LLM-generated architecture descriptions rather than parsing source code directly, it can handle Go, Rust, Java, C++, or any language the underlying LLM can comprehend. The repository's Python example in `experiments/mco-showcase/` demonstrates this cross-language capability explicitly.

### What version of Node.js does Archify require?

Archify requires **Node.js 18 or higher**, as specified in [`archify/package.json`](https://github.com/tt-a1i/archify/blob/main/archify/package.json) under the `engines` field. This ensures native support for ESM modules and modern JavaScript features used throughout the codebase.