nrwl/nx

The Monorepo Platform that amplifies both developers and AI agents. Nx optimizes your builds, scales your CI, and fixes failed PRs automatically. Ship in half the time.

28,452 stars TypeScript 10 components 3 connections

A monorepo platform with Rust-powered builds and integrated CI solution

Data flows from user commands through the CLI to plugin generators, which read project configurations, apply transformations via AST manipulation, and write updated files back to the workspace.

Under the hood, the system uses 2 feedback loops, 3 data pools, 3 control points to manage its runtime behavior.

Structural Verdict

A 10-component dev tool with 3 connections. 4884 files analyzed. Loosely coupled — components are relatively independent.

How Data Flows Through the System

Data flows from user commands through the CLI to plugin generators, which read project configurations, apply transformations via AST manipulation, and write updated files back to the workspace.

Command Input — User runs Nx CLI commands or workspace creation tools
Plugin Discovery — Nx discovers and loads relevant plugins based on project configuration (config: plugins)
Schema Validation — Generator options are normalized and validated against schemas
AST Processing — Configuration files are parsed, modified, and updated using TypeScript AST
File Generation — New files and configurations are written to the workspace

System Behavior

How the system actually operates at runtime — where data accumulates, what loops, what waits, and what controls what.

Data Pools

Plugin Registry (in-memory)
Cached plugin configurations and generators

Project Graph (cache)
Dependency relationships between workspace projects

Build Cache (file-store)
Cached build outputs and task results

Feedback Loops

Configuration Validation Loop (retry, balancing) — Trigger: Invalid schema options provided. Action: Re-prompt user for correct values. Exit: Valid options provided.
AST Parse-Modify Loop (retry, balancing) — Trigger: Configuration file needs updates. Action: Parse AST, apply transformations, validate syntax. Exit: Valid configuration written.

Delays & Async Processing

Plugin Loading (async-processing, ~variable) — CLI startup time affected by plugin discovery and initialization
AST Processing (async-processing, ~100-500ms per file) — Configuration updates require parsing and transformation time
E2E Test Execution (scheduled-job, ~minutes to hours) — Package validation occurs in CI after changes

Control Points

NX_ADD_PLUGINS (env-var) — Controls: Whether plugins are automatically added to new projects. Default: true by default
useInferencePlugins (feature-flag) — Controls: Enables automatic plugin inference from project structure. Default: null
packageManager (runtime-toggle) — Controls: Which package manager to use for workspace operations. Default: pnpm@10.28.2

Package Structure

This monorepo contains 12 packages:

nx (app)
Core Nx CLI and workspace management functionality

devkit (library)
Shared utilities and APIs for building Nx plugins

create-nx-workspace (app)
CLI tool for creating new Nx workspaces

angular (library)
Angular framework integration plugin

react (library)
React framework integration plugin

next (library)
Next.js framework integration plugin

webpack (library)
Webpack build tool integration

vite (library)
Vite build tool integration

jest (library)
Jest testing framework integration

nx-dev (app)
Nx documentation website built with Next.js

graph-client (app)
Interactive dependency graph visualization web app

e2e-utils (library)
Shared utilities for end-to-end testing

Technology Stack

TypeScript (framework)
Primary development language

Rust (library)
Performance-critical build operations

Next.js (framework)
Documentation website framework

React (framework)
UI components for graph visualization

Jest (testing)
Testing framework

tsquery (library)
TypeScript AST querying and manipulation

yargs (library)
CLI argument parsing

enquirer (library)
Interactive CLI prompts

Key Components

configurationGenerator (function) — Generates Cypress test configuration for Nx projects packages/cypress/src/generators/configuration/configuration
addDefaultE2EConfig (function) — Adds default e2e configuration to Cypress config files using AST manipulation packages/cypress/src/utils/config.ts
normalizeOptions (function) — Normalizes and validates options for Detox application generation packages/detox/src/generators/application/lib/normalize-options.ts
interpolatePattern (function) — Interpolates pattern tokens in strings for Docker configuration packages/docker/src/utils/interpolate-pattern.ts
DotNetPluginOptions (type-def) — Configuration interface for .NET plugin target definitions packages/dotnet/src/plugins/create-nodes.ts
createNodesV2 (function) — Plugin entry point for Docker project configuration packages/docker/index.ts
nxE2EPreset (function) — Preset configuration function for Cypress e2e testing in Nx packages/cypress/src/utils/config.ts
commandsObject (cli-command) — Main CLI command handler for workspace creation packages/create-nx-workspace/bin/index.ts
detoxApplicationGenerator (function) — Generates Detox mobile testing applications packages/detox/index.ts
analyzeProjects (function) — Analyzes .NET projects to generate Nx target configurations packages/dotnet/src/plugins/create-nodes.ts

Configuration

pnpm-workspace.yaml (yaml)

packages (array, unknown) — default: packages/*,e2e/*,graph/*,nx-dev/*,tools/*,astro-docs,examples/*/*,examples/angular-rspack/module-federation/host,examples/angular-rspack/module-federation/remote,packages/nx/native-packages/*
overrides.minimist (string, unknown) — default: ^1.2.6
overrides.underscore (string, unknown) — default: ^1.12.1
onlyBuiltDependencies (array, unknown) — default: @nestjs/core,nx
patchedDependencies.@astrojs/starlight (string, unknown) — default: patches/@astrojs__starlight.patch
catalog.@zkochan/js-yaml (string, unknown) — default: 0.0.7
catalog.chalk (string, unknown) — default: ^4.1.0
catalog.enquirer (string, unknown) — default: ~2.3.6
+78 more parameters

babel.config.json (json)

babelrcRoots (array, unknown) — default: *

nx.json (json)

$schema (string, unknown) — default: packages/nx/schemas/nx-schema.json
namedInputs.default (array, unknown) — default: {projectRoot}/**/*,sharedGlobals
namedInputs.production (array, unknown) — default: default,!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap),!{projectRoot}/tsconfig.spec.json,!{projectRoot}/jest.config.[jt]s,!{projectRoot}/.eslintrc.json,!{projectRoot}/.storybook/**/*,!{projectRoot}/**/*.stories.@(js|jsx|ts|tsx|mdx),!{projectRoot}/tsconfig.storybook.json,!{projectRoot}/src/test-setup.[jt]s
namedInputs.sharedGlobals (array, unknown) — default: {workspaceRoot}/babel.config.json,{workspaceRoot}/.nx/workflows/agents.yaml,{workspaceRoot}/.github/workflows/ci.yml
namedInputs.copyReadme (array, unknown) — default: {projectRoot}/README.md,{projectRoot}/readme-template.md,{workspaceRoot}/scripts/copy-readme.js,{workspaceRoot}/scripts/readme-fragments/**/*,{workspaceRoot}/.prettierignore
namedInputs.native (array, unknown) — default: {projectRoot}/**/*.rs,{projectRoot}/**/Cargo.*,[object Object],[object Object],[object Object]
namedInputs.e2eInputs (array, unknown) — default: default,{workspaceRoot}/scripts/patched-jest-resolver.js,{workspaceRoot}/jest.preset.js,{workspaceRoot}/e2e/jest.preset.e2e.js,{workspaceRoot}/.verdaccio/config.yml,{workspaceRoot}/scripts/local-registry/**/*,{workspaceRoot}/scripts/nx-release.ts,[object Object],[object Object],[object Object],[object Object],[object Object]
release.projects (array, unknown) — default: packages/*,packages/nx/native-packages/*
+61 more parameters

opencode.json (json)

$schema (string, unknown) — default: https://opencode.ai/config.json
mcp.nx-mcp.type (string, unknown) — default: local
mcp.nx-mcp.command (array, unknown) — default: npx,nx,mcp
mcp.nx-mcp.enabled (boolean, unknown) — default: true

Explore the interactive analysis

See the full architecture map, data flow, and code patterns visualization.

Analyze on CodeSea

Related Dev Tool Repositories

Frequently Asked Questions

What is nx used for?

A monorepo platform with Rust-powered builds and integrated CI solution nrwl/nx is a 10-component dev tool written in TypeScript. Loosely coupled — components are relatively independent. The codebase contains 4884 files.

How is nx architected?

nx is organized into 5 architecture layers: Core Platform, Framework Plugins, Build Tools, Documentation & Graph, and 1 more. Loosely coupled — components are relatively independent. This layered structure keeps concerns separated and modules independent.

How does data flow through nx?

Data moves through 5 stages: Command Input → Plugin Discovery → Schema Validation → AST Processing → File Generation. Data flows from user commands through the CLI to plugin generators, which read project configurations, apply transformations via AST manipulation, and write updated files back to the workspace. This pipeline design reflects a complex multi-stage processing system.

What technologies does nx use?

The core stack includes TypeScript (Primary development language), Rust (Performance-critical build operations), Next.js (Documentation website framework), React (UI components for graph visualization), Jest (Testing framework), tsquery (TypeScript AST querying and manipulation), and 2 more. A focused set of dependencies that keeps the build manageable.

What system dynamics does nx have?

nx exhibits 3 data pools (Plugin Registry, Project Graph), 2 feedback loops, 3 control points, 3 delays. The feedback loops handle retry and retry. These runtime behaviors shape how the system responds to load, failures, and configuration changes.

What design patterns does nx use?

5 design patterns detected: Plugin Architecture, Code Generation, AST Manipulation, Options Normalization, Plugin Registration.

Analyzed on March 31, 2026 by CodeSea. Written by Karolina Sarna.