# Egonex-AI Understand-Anything Supported Frameworks: 12 Language Groups and Layer Detection

> Discover how Egonex AI Understand Anything supports 12 programming languages to auto-detect frameworks, partition codebases into layers, and provide contextual explanations for better impact analysis.

- Repository: [Egonex/Understand-Anything](https://github.com/Egonex-AI/Understand-Anything)
- Tags: getting-started
- Published: 2026-06-13

---

**Egonex-AI Understand-Anything automatically detects frameworks across 12 programming languages—including TypeScript, Python, Java, and Rust—to partition codebases into architectural layers that drive contextual explanations and impact analysis.**

The repository `Egonex-AI/Understand-Anything` implements an **I² (Infrastructure-Integration)** framework detection step that parses dependency files like [`package.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/package.json), [`requirements.txt`](https://github.com/Egonex-AI/Understand-Anything/blob/main/requirements.txt), and `Gemfile` to map package names to framework identifiers. This detection logic resides in the *project-scanner* agent and determines how the system categorizes code into presentation, API, and data layers. The framework identifiers are stored in the `project.frameworks` array and consumed by downstream modules to build knowledge graphs and generate explanations.

## Supported Frameworks Across 12 Languages

Understand-Anything supports framework detection across 12 major programming languages, with specific package mappings defined in language-specific markdown files under `understand-anything-plugin/skills/understand/languages/`. The following table lists the officially supported frameworks by language:

| Language | Detected Frameworks |
|----------|---------------------|
| **TypeScript** | Angular, Next.js, NestJS, Express |
| **JavaScript** | Vue, Express, Next.js, Svelte |
| **Python** | Django, FastAPI, Flask |
| **Ruby** | Rails, RSpec, Grape |
| **PHP** | Laravel, Symfony, Slim, CodeIgniter |
| **Java** | Spring Boot, Quarkus, Micronaut, Hibernate |
| **Kotlin** | Ktor, Exposed, Koin |
| **Go** | Gin, Echo, Fiber |
| **Rust** | Actix-web, Axum, Rocket |
| **Swift** | UIKit, SwiftUI, Vapor, Combine, Core Data |
| **C#** | ASP.NET Core, Blazor, xUnit |
| **C++** | Qt, Catch2, Google Test, gRPC |

Each entry is defined in its respective language file (e.g., [`typescript.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/typescript.md), [`python.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/python.md)) and specifies the dependency patterns that trigger detection.

## How Framework Detection Drives Layer Detection

The framework identifiers populated during the I² detection step directly influence how the *context-builder* and *explain-builder* modules partition the codebase into architectural layers.

### Graph Construction

The *project-scanner* agent constructs a knowledge graph where nodes represent files, functions, or classes. Detected frameworks are stored in the `project.frameworks` array according to the JSON schema defined in [`understand-anything-plugin/agents/project-scanner.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/understand-anything-plugin/agents/project-scanner.md). This array serves as the semantic foundation for layer assignment.

### Layer Heuristics

The system uses the `layers` collection to group nodes by architectural purpose. Framework detection guides these heuristics through specific mapping rules:

- **UI frameworks** (React, Vue, Angular, SwiftUI, Svelte) → Nodes are placed into the *Presentation* or *UI* layer
- **Server-side frameworks** (NestJS, Express, Django, Flask, Spring Boot, Gin, FastAPI) → Nodes become part of the *API* or *Backend* layer
- **Data-oriented frameworks** (Hibernate, Prisma, TypeORM, Sequelize, gRPC) → Nodes are grouped into the *Data* layer

The mapping logic in [`onboard-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/onboard-builder.ts) and [`explain-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/explain-builder.ts) checks whether a node's `id` appears in a layer's `nodeIds` list to determine membership.

### Cross-Layer Impact Analysis

When code changes touch files belonging to different framework-driven layers, the *diff-analyzer* module reports a "cross-layer impact" in [`diff-analyzer.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/diff-analyzer.ts). This analysis lists each affected layer by name, enabling developers to understand architectural ripple effects across the stack.

### Layer-Specific Explanations

The final explanation output includes an "Architectural Layer" heading derived from the framework mapping. As implemented in [`explain-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/explain-builder.ts), the system inserts the layer name and description (e.g., "API Layer" for Express routes) to provide architectural context for code explanations.

## Implementation Code Examples

The following TypeScript examples demonstrate how framework detection and layer assignment are implemented in the Understand-Anything codebase.

Detecting frameworks during project scanning:

```typescript
// Example: Detecting a framework during project scanning
const frameworks = [] as string[];
if (packageJson.dependencies?.['@angular/core']) frameworks.push('Angular');
if (packageJson.dependencies?.['next']) frameworks.push('Next.js');
// ... (similar checks for each language)
// Result stored in the project metadata
project.frameworks = frameworks;

```

Assigning nodes to layers based on detected frameworks:

```typescript
// Example: Assigning nodes to a layer based on a detected framework
const uiLayer = {
  id: 'layer:ui',
  name: 'UI Layer',
  description: 'All front‑end components (React, Vue, Angular, etc.)',
  nodeIds: []
};
graph.nodes.forEach(node => {
  if (node.path.match(/\/src\/components\//) && project.frameworks.includes('React')) {
    uiLayer.nodeIds.push(node.id);
  }
});
graph.layers.push(uiLayer);

```

Rendering layer information in explanations:

```typescript
// Example: Rendering layer info in an explanation
if (layer) {
  lines.push(`## Architectural Layer: ${layer.name}`);

  lines.push(layer.description);
}

```

## Summary

- **Egonex-AI Understand-Anything** supports framework detection across **12 programming languages**, from TypeScript and Python to Rust and C++.
- The **I² framework detection** step parses dependency files and populates the `project.frameworks` array with identifiers like "Django", "Spring Boot", or "React".
- Framework detection drives **layer heuristics** that partition code into UI, API, and Data layers based on the specific frameworks detected.
- The **diff-analyzer** uses these layers to report cross-layer impacts, while the **explain-builder** includes architectural layer context in generated explanations.
- Implementation files include [`project-scanner.md`](https://github.com/Egonex-AI/Understand-Anything/blob/main/project-scanner.md) for detection rules, [`onboard-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/onboard-builder.ts) for layer building, and [`explain-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/explain-builder.ts) for rendering layer contexts.

## Frequently Asked Questions

### What file types does the project scanner analyze for framework detection?

The project scanner analyzes standard dependency manifests including [`package.json`](https://github.com/Egonex-AI/Understand-Anything/blob/main/package.json) for JavaScript/TypeScript, [`requirements.txt`](https://github.com/Egonex-AI/Understand-Anything/blob/main/requirements.txt) for Python, `Gemfile` for Ruby, [`pom.xml`](https://github.com/Egonex-AI/Understand-Anything/blob/main/pom.xml) or `build.gradle` for Java, and similar language-specific configuration files. These files are parsed during the I² detection step to identify imported frameworks.

### How does Understand-Anything handle projects using multiple frameworks?

When multiple frameworks are detected, the `project.frameworks` array contains all identified identifiers. The layer heuristics in [`context-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/context-builder.ts) and [`explain-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/explain-builder.ts) can assign nodes to multiple layers or composite layers. For example, a full-stack Next.js application might have nodes assigned to both the UI layer (for frontend components) and the API layer (for API routes).

### Can developers customize which frameworks are detected or how they map to layers?

The framework definitions are stored in the language-specific markdown files under `understand-anything-plugin/skills/understand/languages/`. While the current implementation uses predefined mappings, the modular structure allows for extension by adding new framework entries to these files and updating the layer heuristics in [`onboard-builder.ts`](https://github.com/Egonex-AI/Understand-Anything/blob/main/onboard-builder.ts) to recognize additional framework identifiers.

### What is the difference between the I² framework detection and the layer detection in Understand-Anything?

**I² (Infrastructure-Integration)** framework detection is the initial parsing phase that identifies which frameworks are present in the codebase by examining dependency files. **Layer detection** is the subsequent graph analysis phase that uses these framework identifiers to categorize code nodes into architectural layers (Presentation, API, Data) based on heuristic rules defined in the builder modules.