chalk

Terminal string styling done right

weekly downloads370.0M

versionv5.6.2

licenseMIT

categorytoolchain

colorcolourcolorsterminalconsoleclistringansistylestylesttyformattingrgb256shellxtermlogloggingcommand-linetext

Overview

Chalk is a widely-adopted npm package that applies ANSI escape codes to terminal strings, enabling colored and styled text output in Node.js command-line applications. With over 370 million weekly downloads, it's become the de facto standard for CLI styling, used by tools like Webpack, ESLint, and Gatsby to provide visual feedback, highlight errors, and improve developer experience in terminal environments.

The package solves a fundamental problem in CLI development: raw terminal output lacks visual hierarchy. Without styling, errors blend with warnings, success messages get lost in logs, and users struggle to parse dense textual output. Chalk addresses this by exposing a simple, chainable API that wraps strings with ANSI codes, automatically detecting terminal capabilities to provide the best color depth available—from basic 16 colors to Truecolor with 16 million hues.

Designed for Node.js environments, Chalk handles terminal compatibility transparently. It detects color support levels (none, basic, 256-color, Truecolor) and adjusts output accordingly, downsampling RGB values when necessary. The library supports nesting styles, composing multiple modifiers (bold, underline, background colors), and gracefully degrades in environments without color support. This makes it particularly valuable for building cross-platform CLI tools that work consistently across Windows, macOS, and Linux terminals.

Developers choose Chalk for its intuitive API and reliability, though it's worth noting that version 5.6.1 experienced a security incident in September 2025 involving account compromise. The malicious version targeted cryptocurrency operations in browser bundles but was quickly removed. Current versions are safe, though some teams have migrated to lighter alternatives like picocolors for supply chain risk mitigation.

Quick Start

typescript

import chalk from 'chalk';

function logBuildResults(stats) {
  console.log(chalk.bold('\nBuild Summary\n'));
  
  console.log(
    chalk.green('✓'),
    chalk.gray('Compiled successfully in'),
    chalk.cyan(`${stats.time}ms`)
  );
  
  if (stats.warnings > 0) {
    console.log(
      chalk.yellow('⚠'),
      chalk.yellow.bold(`${stats.warnings} warnings`)
    );
  }
  
  console.log(
    chalk.bgBlue.white.bold(' OUTPUT '),
    chalk.underline(stats.outputPath)
  );
  
  stats.files.forEach(file => {
    const sizeColor = file.size > 500000 ? chalk.red : chalk.green;
    console.log(
      '  ',
      chalk.dim(file.name.padEnd(30)),
      sizeColor(`${(file.size / 1024).toFixed(2)} KB`)
    );
  });
  
  if (stats.errors > 0) {
    console.log(
      '\n' + chalk.bgRed.white.bold(` ${stats.errors} ERROR(S) `) + '\n'
    );
    stats.errorMessages.forEach(err => {
      console.log(chalk.red(err.message));
      console.log(chalk.gray(err.stack));
    });
  }
}

logBuildResults({
  time: 2341,
  warnings: 2,
  errors: 0,
  outputPath: './dist/bundle.js',
  files: [
    { name: 'bundle.js', size: 245000 },
    { name: 'vendor.js', size: 680000 },
    { name: 'styles.css', size: 45000 }
  ],
  errorMessages: []
});

Use Cases

Build tool output formatting: Tools like Webpack and Vite use Chalk to color-code compilation results—green for successful builds, red for errors, yellow for warnings. This lets developers instantly assess build status without reading full logs.

CLI application user interfaces: Interactive command-line tools (generators, scaffolding utilities, deployment scripts) use Chalk to create visual structure with colored prompts, progress indicators, and formatted tables. For example, a deployment script might show blue info messages, yellow deployment steps, and green success confirmations.

Logging and debugging enhancement: Application loggers integrate Chalk to distinguish log levels visually—gray for debug, cyan for info, red for errors. This makes scanning production logs or development console output significantly faster than parsing monochrome text streams.

Test runner output: Testing frameworks like Jest and Mocha use Chalk to highlight passing tests (green checkmarks), failing assertions (red crosses), and test suite summaries. The visual differentiation helps developers quickly locate failures in large test suites.

Error message highlighting: CLI tools use Chalk to make error messages more scannable by coloring stack traces, highlighting file paths in yellow, and making error codes stand out in red. This reduces cognitive load when debugging failed operations.

Pros & Cons

Pros

+Highly intuitive chainable API that reads naturally (chalk.bold.red('text')) with minimal learning curve
+Automatic terminal capability detection with intelligent color downsampling—no manual configuration needed for cross-platform compatibility
+Comprehensive styling options including 16M colors via RGB/hex, modifiers (bold, dim, italic), and nesting support for complex formatting
+Zero runtime dependencies in recent versions, reducing supply chain surface area and bundle bloat
+Massive ecosystem adoption means excellent compatibility with popular CLI frameworks and extensive community resources

Cons

−ESM-only since version 5.0, breaking compatibility with CommonJS projects that can't easily migrate (stuck on v4.x)
−September 2025 security incident (v5.6.1 compromise) raised supply chain concerns, prompting some teams to seek alternatives despite resolution
−Heavier than minimalist alternatives like picocolors (~15KB vs ~2KB), which matters for serverless or edge environments with cold start constraints
−Chaining creates intermediate style objects that add minor overhead—negligible for typical CLI use but measurable in high-frequency logging scenarios
−Color level customization requires instantiating new Chalk instances rather than simple config flags, adding boilerplate for advanced use cases

Alternatives

picocolorsv1.1.1

The tiniest and the fastest library for terminal output formatting with ANSI colors

toolchainterminalcolors

111.7M / week

Comparisons

Install

bash

npm install chalk

bash

pnpm add chalk

bash

bun add chalk

Overview

Quick Start

typescript

import chalk from 'chalk';

function logBuildResults(stats) {
  console.log(chalk.bold('\nBuild Summary\n'));
  
  console.log(
    chalk.green('✓'),
    chalk.gray('Compiled successfully in'),
    chalk.cyan(`${stats.time}ms`)
  );
  
  if (stats.warnings > 0) {
    console.log(
      chalk.yellow('⚠'),
      chalk.yellow.bold(`${stats.warnings} warnings`)
    );
  }
  
  console.log(
    chalk.bgBlue.white.bold(' OUTPUT '),
    chalk.underline(stats.outputPath)
  );
  
  stats.files.forEach(file => {
    const sizeColor = file.size > 500000 ? chalk.red : chalk.green;
    console.log(
      '  ',
      chalk.dim(file.name.padEnd(30)),
      sizeColor(`${(file.size / 1024).toFixed(2)} KB`)
    );
  });
  
  if (stats.errors > 0) {
    console.log(
      '\n' + chalk.bgRed.white.bold(` ${stats.errors} ERROR(S) `) + '\n'
    );
    stats.errorMessages.forEach(err => {
      console.log(chalk.red(err.message));
      console.log(chalk.gray(err.stack));
    });
  }
}

logBuildResults({
  time: 2341,
  warnings: 2,
  errors: 0,
  outputPath: './dist/bundle.js',
  files: [
    { name: 'bundle.js', size: 245000 },
    { name: 'vendor.js', size: 680000 },
    { name: 'styles.css', size: 45000 }
  ],
  errorMessages: []
});

Use Cases

Pros & Cons

Pros

+Highly intuitive chainable API that reads naturally (chalk.bold.red('text')) with minimal learning curve
+Automatic terminal capability detection with intelligent color downsampling—no manual configuration needed for cross-platform compatibility
+Comprehensive styling options including 16M colors via RGB/hex, modifiers (bold, dim, italic), and nesting support for complex formatting
+Zero runtime dependencies in recent versions, reducing supply chain surface area and bundle bloat
+Massive ecosystem adoption means excellent compatibility with popular CLI frameworks and extensive community resources

Cons

−ESM-only since version 5.0, breaking compatibility with CommonJS projects that can't easily migrate (stuck on v4.x)
−September 2025 security incident (v5.6.1 compromise) raised supply chain concerns, prompting some teams to seek alternatives despite resolution
−Heavier than minimalist alternatives like picocolors (~15KB vs ~2KB), which matters for serverless or edge environments with cold start constraints
−Chaining creates intermediate style objects that add minor overhead—negligible for typical CLI use but measurable in high-frequency logging scenarios
−Color level customization requires instantiating new Chalk instances rather than simple config flags, adding boilerplate for advanced use cases