Open-source alternatives to Node Jscs

Standard is a suite of static analysis tools for JavaScript, comprising a linter, formatter, and a predefined style guide. It functions as a static code analyzer that scans source code for style violations and potential errors without executing the program. The project provides an automatic code fixer that rewrites source code to resolve formatting issues and enforce syntax consistency. It implements a standardized set of rules for JavaScript formatting and syntax to ensure a uniform appearance across different projects. The system covers a wide range of static analysis capabilities, includi

RuboCop is a static code analyzer, linter, and formatter for the Ruby language. It detects style violations, potential bugs, and code smells by scanning source code without executing the program. The tool enforces a predefined Ruby style guide by flagging deviations and automatically rewriting source code to ensure consistency across projects. It includes a language server that provides real-time analysis and formatting suggestions directly within text editors.

This project is a dependency reduction tool and ESLint plugin designed to remove heavy utility libraries from JavaScript projects. It functions as a static analysis tool that identifies third-party library method calls and suggests native ECMAScript alternatives to decrease bundle size. The tool provides a curated replacement guide consisting of native JavaScript code snippets that replicate the behavior of common external utility functions. This allows developers to migrate older codebases to current language standards and reduce project complexity. The system integrates into the linting li

JSHint is a JavaScript static analysis tool and linter designed to detect errors and enforce coding standards. It functions as a syntax validator that scans source code to identify potential logic problems and programming mistakes before the code is executed. The tool provides a command line interface for analyzing files and directories. It supports the export of analysis results into standardized formats such as Checkstyle for integration with external build tools. Analysis is managed through a system of linting rule management and environment global configuration. This includes the ability

xo is a zero-configuration linting tool for JavaScript and TypeScript. It functions as a wrapper for the ESLint engine, providing a set of strict default rules and static analysis to enforce professional coding standards without requiring manual configuration files. The tool distinguishes itself by providing a zero-config runtime that automatically determines parser settings and linting rules at execution time. It includes a code style formatter to standardize indentation and syntax across all project files. The project covers automated error correction and source code formatting to eliminat

eslint-plugin-unicorn is an ESLint plugin that provides a large set of opinionated lint rules for JavaScript and TypeScript projects. Its primary purpose is to enforce code quality, prevent common errors and anti-patterns, and promote a consistent coding style across a codebase. The plugin distinguishes itself by offering an opinionated preset configuration that imposes a specific coding style rather than leaving all choices to the user. Its rules are specifically designed to catch logical mistakes and code smells that go beyond standard ESLint rules. As an added capability, the plugin also e

xo is a zero-config linting tool and ESLint wrapper that provides opinionated default rules for JavaScript and TypeScript. It functions as a static analysis tool to enforce code style and readability standards immediately upon installation without requiring manual configuration. The tool distinguishes itself by providing a zero-config development workflow that eliminates the need for complex configuration files. It supports incremental codebase cleanup by allowing users to ignore known violations through a suppressions file, facilitating the gradual adoption of strict rules in existing projec

This project is a unified toolchain for JavaScript and TypeScript development, providing a suite of specialized tools for bundling, parsing, linting, and formatting source code. The toolchain is implemented in Rust and utilizes a shared internal representation to allow multiple tools to operate on the same parsed source code. It employs a parallelized analysis pipeline and single-pass parsing with error recovery to process files across CPU cores. The suite covers several core capability areas, including static analysis for identifying programmatic errors, automated style standardization, and

oxc is a high-performance JavaScript toolchain developed in Rust for parsing, transforming, and analyzing JavaScript and TypeScript source code. It provides a set of core utilities including a parser that converts code into an abstract syntax tree, a linter for identifying problematic patterns, a formatter for standardizing visual style, and a minifier for reducing production file sizes. The project focuses on high-performance execution through a system design that utilizes single-pass parsing, zero-copy string slicing, and parallel worker processing to handle large codebases. It further opti

SwiftLint is a static analysis tool and code formatter designed to enforce consistent coding styles and identify semantic issues within Swift source code. It functions as a command-line utility that evaluates code against established conventions to ensure uniform structure and architectural standards across a project. The tool distinguishes itself through a custom linting engine that leverages compiler-integrated syntax analysis to perform deep inspections of code structure. Beyond simple pattern matching, it supports automated source code transformation to correct formatting violations and r

Standard is a zero-configuration static analyzer, linter, and formatter for JavaScript. It functions as a style guide that enforces consistent coding rules and identifies programming errors without requiring manual configuration files. The tool distinguishes itself by providing an automatic code fixer that scans source files to correct style violations and ensure a uniform codebase. It implements a predefined rule set to eliminate the need for project-specific configuration. The project covers a broad range of static analysis capabilities, including support for experimental language syntax a

Revive is a configurable static analysis linter and code quality tool for Go. It analyzes source code to detect common coding mistakes, identify style violations, and enforce language standards without executing the program. The project functions as both a command line tool and an embeddable analysis engine. This allows the core linting logic to be integrated as a library into other Go applications for programmatic code inspection. The tool supports custom rule sets and severity levels managed through a structured configuration file. It provides capabilities for suppressing specific warnings

This project is a comprehensive collection of Python programming education materials, including tutorials, exercises, and curated code samples. It serves as a learning curriculum and software engineering toolkit, utilizing Jupyter Notebooks to combine executable code with descriptive educational text. The repository provides practical implementation guides for building large language model applications, such as retrieval-augmented generation systems, stateful AI agents, and machine learning workflows. It distinguishes itself by offering a structured approach to agentic coding workflows, cover

This project is an ESLint plugin and static code analyzer for Vue.js. It provides a suite of linting rules to detect common errors, validate templates and scripts, and enforce consistent coding standards across single-file components. The plugin distinguishes itself by analyzing the relationship between script and template blocks to validate cross-block property usage. It identifies bug-prone patterns, detects deprecated APIs, and restricts dangerous patterns such as raw HTML rendering to prevent security vulnerabilities. Its broader capabilities cover component validation for naming and str

lua-language-server is a static analysis tool and type checker for the Lua language that implements the Language Server Protocol. It provides a system for detecting type mismatches, unused code, and logic errors in source files. The project features an inference-based type system that deduces variable types and supports optional annotations and meta files to enforce type safety. It allows for the definition of custom types and function signatures, including support for overloads and member visibility controls. The server provides a broad set of IDE capabilities, including real-time code auto

RuboCop is a static code analyzer and linter for Ruby. It functions as a static analysis tool designed to detect potential bugs, identify style violations, and improve overall code quality in Ruby projects. The project provides an automated code formatter that rewrites source code to align with established community standards. It also implements a language server protocol to surface linting and formatting errors directly within text editors. Its capabilities cover automated code linting and the analysis of Ruby code style to ensure consistency across a project. These functions are driven by

This project provides a comprehensive architectural framework and set of standardized patterns for building, securing, and scaling production-ready Node.js applications. It serves as a foundational guide for establishing consistent development workflows, operational observability, and reliable service integration across distributed software systems. The framework distinguishes itself by emphasizing a schema-first approach to API development, ensuring that interface definitions drive the creation of server stubs, client libraries, and type definitions. It promotes a cloud-native posture by int

CodeGraphContext is a code graph indexer and visualization tool that analyzes source code to build graphs of functions, classes, and inheritance relationships. It functions as a Model Context Protocol server, providing a structured codebase index to AI assistants for context retrieval and natural language querying. The project features an interactive web interface that uses force-directed layouts to visualize code dependencies and symbols. To accelerate the setup of large projects, it supports the import of pre-calculated knowledge bundles for popular repositories. The system provides capabi

Biome is a unified developer tooling suite that provides code formatting, linting, and static analysis for JavaScript and TypeScript projects. It functions as a command-line interface designed to automate the maintenance of code quality and style consistency throughout the development lifecycle. The tool distinguishes itself through a high-performance engine built in Rust, which utilizes a single-pass abstract syntax tree to perform formatting and linting simultaneously. By leveraging parallel multi-threaded execution and incremental file system caching, it minimizes latency during analysis t

This project is a development toolkit and starter kit for creating custom WordPress themes. It provides a standardized scaffolding tool to initialize a minimal codebase and directory structure, serving as a foundation for building custom site designs. The toolkit includes a build pipeline that automates the compilation of Sass into browser-ready CSS and the generation of mirrored right-to-left stylesheets. It further assists in theme preparation through a translation template generator that extracts translatable strings into portable object files. The system covers a broad range of developme

Flake8 is a Python style checker and static analysis tool that identifies programmatic errors and violations of coding standards in source files. It serves as a linting wrapper that aggregates multiple checkers into a single interface, functioning as a pluggable framework for Python code analysis. The tool incorporates a cyclomatic complexity analyzer to measure the logical complexity of functions and identify code that requires refactoring. It is designed for extensibility, allowing the integration of custom plugins and rules through defined entry points. The system provides capabilities fo

This project is a comprehensive, curated directory of high-quality libraries, tools, and educational resources for C and C++ development. It serves as an ecosystem discovery index, helping developers navigate the vast landscape of third-party components, frameworks, and technical documentation available for the language. The collection is distinguished by its focus on high-performance systems programming and technical mastery. It provides deep coverage of specialized domains including SIMD-accelerated data processing, compile-time template metaprogramming, and asynchronous event-driven archit

This project is a JavaScript style guide and Node.js coding standard designed to ensure the creation of consistent, maintainable, and readable code. It serves as a comprehensive reference for naming conventions, formatting, and architectural patterns. The project provides a linting configuration template that allows for the automatic enforcement of these standards. This includes predefined linting presets and a base of rules used to perform logic checks and automatic formatting across a codebase. The guidelines cover a broad range of standardization capabilities, including code and file form

js-beautify is a web language beautifier and code formatter designed to standardize the layout and structure of JavaScript, HTML, and CSS files. It reorganizes source code into a consistent, readable style by applying configurable indentation and spacing rules. The project includes a utility for unpacking minified scripts, which transforms compressed or obfuscated JavaScript into a human-readable format. It provides a command-line interface for executing bulk code reformatting across multiple files. The tool supports customizable formatting rules and language-specific overrides, which can be

This project is a comprehensive collection of pre-commit hooks designed to automate code linting, style enforcement, and file validation before changes are committed to version control. It provides a suite of ready-to-use scripts that serve as quality guards, including static analysis hooks, configuration file validators, and tools for maintaining version control integrity. The collection distinguishes itself by offering specialized guards for repository health and security. This includes detection of leaked credentials and private keys, prevention of large file commits, and enforcement of br

pycodestyle is a Python code quality utility that checks source files against the PEP 8 style guide, reporting deviations as a static analysis tool. Its primary function is to enforce consistent code formatting by scanning files and flagging violations with precise line and column numbers for direct integration into editors or workflows. The tool combines token-based pattern matching with abstract syntax tree (AST) context enrichment, enabling it to evaluate both surface-level formatting and deeper structural patterns. Its architecture supports custom validation rules through a plugin interfa

rustfmt is a tool that automatically rewrites Rust source code to adhere to a consistent and standardized style guide. It functions as both a code formatter for transforming source files and a style linter used to verify if code matches required formatting rules. The system is configurable, allowing for the definition of custom formatting rules and language editions through configuration files to override default styles. It also supports selective formatting by using dedicated skip markers to prevent specific blocks of code from being modified. The tool provides capabilities for both source