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

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, the project declares itself as a JavaScript module with Node engine requirements:

{
  "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 shows installation via npm/npx:

npx skills add tt-a1i/archify -g

The 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 (lines 4574-4621) visualizes a Python runtime (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:

# 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	Declares Node engine and JavaScript module type
archify/bin/archify.mjs	Language-agnostic CLI entry point
README.md	Documents agent-skill architecture, not parser-based
examples/web-app.html	JavaScript/Node demonstration
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 under the engines field. This ensures native support for ESM modules and modern JavaScript features used throughout the codebase.

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