# Which Frameworks Are Detected by Understand-Anything? Complete Framework Registry Guide

> Discover which frameworks Understand Anything detects automatically. Explore the complete registry of supported web and server-side frameworks like React, Django, and Spring.

- Repository: [Yuxiang Lin/Understand-Anything](https://github.com/Lum1104/Understand-Anything)
- Tags: complete-guide
- Published: 2026-06-01

---

**Understand-Anything automatically detects ten major web and server-side frameworks—including React, Django, Spring, and Next.js—by scanning manifest files like [`package.json`](https://github.com/Lum1104/Understand-Anything/blob/main/package.json) and [`requirements.txt`](https://github.com/Lum1104/Understand-Anything/blob/main/requirements.txt) for framework-specific signatures defined in its built-in registry.**

Understand-Anything is an AI-powered code analysis tool that identifies the technology stack of any project by inspecting dependency manifests. To answer which frameworks are detected by Understand-Anything, we need to examine the built-in framework registry located in the core language package, which currently supports ten popular frameworks across JavaScript, Python, Java, Go, and Ruby ecosystems.

## Complete List of Built-In Frameworks

As of the latest `main` branch, Understand-Anything recognizes exactly ten frameworks. Each framework is defined by a configuration file in `packages/core/src/languages/frameworks/` and registered via `builtinFrameworkConfigs` in [`packages/core/src/languages/frameworks/index.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/packages/core/src/languages/frameworks/index.ts).

The following frameworks are automatically detected:

- **Vue.js** (`vue`) – Detected via `vue` dependency in [`package.json`](https://github.com/Lum1104/Understand-Anything/blob/main/package.json). Source: [`frameworks/vue.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/vue.ts)
- **React** (`react`) – Detected via `react` import or dependency. Source: [`frameworks/react.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/react.ts)
- **Next.js** (`nextjs`) – Detected via `next` dependency. Source: [`frameworks/nextjs.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/nextjs.ts)
- **Express** (`express`) – Node.js web framework detected via `express` dependency. Source: [`frameworks/express.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/express.ts)
- **Django** (`django`) – Python framework detected via `django` in [`requirements.txt`](https://github.com/Lum1104/Understand-Anything/blob/main/requirements.txt). Source: [`frameworks/django.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/django.ts)
- **Flask** (`flask`) – Python microframework detected via `flask` dependency. Source: [`frameworks/flask.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/flask.ts)
- **FastAPI** (`fastapi`) – Python framework detected via `fastapi` import. Source: [`frameworks/fastapi.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/fastapi.ts)
- **Spring** (`spring`) – Java framework detected via Spring Boot dependencies. Source: [`frameworks/spring.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/spring.ts)
- **Ruby on Rails** (`rails`) – Ruby framework detected via `rails` in `Gemfile`. Source: [`frameworks/rails.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/rails.ts)
- **Gin** (`gin`) – Go web framework detected via `github.com/gin-gonic/gin` import. Source: [`frameworks/gin.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/gin.ts)

## How Framework Detection Works

The framework detection workflow lives in [`packages/core/src/languages/framework-registry.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/packages/core/src/languages/framework-registry.ts) and operates through a four-stage pipeline:

**1. Registry Initialization**

At startup, the `FrameworkRegistry` class is populated with all built-in framework configurations exported from `packages/core/src/languages/frameworks/`. Each configuration defines the framework's ID, display name, and detection patterns.

**2. Manifest Inspection**

The `FrameworkRegistry.detectFrameworks(manifests)` method receives a map of manifest file names to their contents. For each built-in configuration, the system checks whether any identifier listed in the config's `detect` field appears in the manifest content. For example, a [`package.json`](https://github.com/Lum1104/Understand-Anything/blob/main/package.json) containing `"react"` will trigger detection for the React framework.

**3. Deduplication**

Detected frameworks are automatically de-duplicated to prevent duplicate entries when multiple manifests reference the same framework. The result is returned as an array of `FrameworkConfig` objects.

**4. Result Propagation**

The detected framework IDs are stored on the project graph at `project.frameworks` and subsequently surfaced in the onboarding summary, context builder, and LLM prompts throughout the analysis pipeline.

## Accessing Detected Frameworks

You can access framework detection results through both the CLI and programmatic APIs.

### CLI Output

When running the analysis command, detected frameworks appear in the terminal output and generated documentation:

```bash
understand --full

```

The output includes a line similar to:

```

| **Frameworks** | React, Express |

```

### Programmatic Usage (TypeScript)

Import the registry directly to detect frameworks in custom scripts:

```typescript
import { FrameworkRegistry } from "@understand-anything/core/languages/framework-registry.js";
import { readFileSync } from "fs";

// Load a manifest file as a string
const pkgJson = readFileSync("package.json", "utf-8");

// Initialize registry with built-in configs
const registry = FrameworkRegistry.create();

// Detect frameworks
const detected = registry.detectFrameworks({ "package.json": pkgJson });

console.log("Detected frameworks:", detected.map(c => c.id));
// Output: ["react", "express"]

```

### Inside Skills

Framework data is available within skill implementations via the context builder:

```typescript
import { ContextBuilder } from "@understand-anything/skill";

export async function mySkill(context) {
  const ctx = await ContextBuilder.build(context);
  console.log("Project uses:", ctx.frameworks.join(", "));
  // Access: ctx.frameworks returns string[] of framework IDs
}

```

## Summary

- Understand-Anything detects **ten specific frameworks** defined in `packages/core/src/languages/frameworks/`
- Detection relies on scanning **manifest files** ([`package.json`](https://github.com/Lum1104/Understand-Anything/blob/main/package.json), [`requirements.txt`](https://github.com/Lum1104/Understand-Anything/blob/main/requirements.txt), [`Cargo.toml`](https://github.com/Lum1104/Understand-Anything/blob/main/Cargo.toml), etc.) for framework-specific signatures
- The **`FrameworkRegistry.detectFrameworks()`** method handles the inspection and deduplication logic
- Detected frameworks are stored in **`project.frameworks`** and propagated to the context builder and LLM prompts
- Because the framework list is hard-coded via `builtinFrameworkConfigs`, the detection set is currently limited to the built-in definitions

## Frequently Asked Questions

### Can Understand-Anything detect frameworks not in the built-in list?

No. According to the source code analysis, the set of recognizable frameworks is fixed by the configuration files in `packages/core/src/languages/frameworks/`. Because the registry only loads frameworks defined in `builtinFrameworkConfigs` (exported from [`frameworks/index.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/frameworks/index.ts)), it cannot detect custom or niche frameworks without modifying the core source files.

### How does Understand-Anything distinguish between Flask and FastAPI in the same project?

The framework registry treats each detection independently. If your [`requirements.txt`](https://github.com/Lum1104/Understand-Anything/blob/main/requirements.txt) contains both `flask` and `fastapi`, the `detectFrameworks` method will identify both signatures and return an array containing both framework configurations. Both IDs will be stored in `project.frameworks` and de-duplicated if duplicates occur across multiple manifest files.

### Where is the framework detection logic implemented?

The core detection logic resides in **[`packages/core/src/languages/framework-registry.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/packages/core/src/languages/framework-registry.ts)**, specifically within the `FrameworkRegistry` class. The method `detectFrameworks(manifests)` iterates through the built-in configurations and checks for framework-specific strings in the provided manifest contents. Unit tests confirming this behavior are located at [`packages/core/src/__tests__/framework-registry.test.ts`](https://github.com/Lum1104/Understand-Anything/blob/main/packages/core/src/__tests__/framework-registry.test.ts).

### Does Understand-Anything scan source code files for framework imports, or only manifest files?

The detection primarily operates on **manifest files** (dependency declarations). While the `detect` field in framework configurations could theoretically contain import patterns, the standard implementation focuses on [`package.json`](https://github.com/Lum1104/Understand-Anything/blob/main/package.json), [`requirements.txt`](https://github.com/Lum1104/Understand-Anything/blob/main/requirements.txt), [`Cargo.toml`](https://github.com/Lum1104/Understand-Anything/blob/main/Cargo.toml), and similar dependency manifests. The `detectFrameworks` method receives a map of manifest file names to their string contents, making manifest-based detection the primary mechanism.