Open-source alternatives to Ruby Style Guide

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 is a static analysis tool and linter for Ruby on Rails designed to identify architectural smells and violations of best practices. It serves as a code quality linter, architectural auditor, security scanner, and performance analyzer for Rails applications. The tool evaluates the separation of concerns between controllers, models, and view templates to reduce technical debt. It identifies suboptimal coding patterns and enforces stylistic consistency, while specifically scanning for security vulnerabilities such as unprotected mass assignment in models. The analysis surface covers

This project is a collection of Swift coding standards and static analysis rules designed to ensure consistency across Swift projects. It provides a defined set of naming conventions and structural guidelines to maintain a shared style for teams. The repository centers on a SwiftLint configuration used to automate the detection and correction of style violations in source code. This configuration enables automated style enforcement, ensuring that code adheres to organizational standards without requiring manual review. The guidelines cover the standardization of code formatting, naming, and

RuboCop is a static code analyzer, linter, and formatter for the Ruby language. It identifies style violations, smells, and errors in source code to ensure consistency and maintainability based on community guidelines. The project provides automatic source code formatting to rewrite files according to defined stylistic standards. It also functions as a language server protocol implementation, surfacing violations and suggested fixes directly within code editors. The tool covers code complexity monitoring to track the size of classes and methods and employs non-inclusive language detection to

This project is a comprehensive, curated directory of static analysis, linting, and security scanning utilities. It serves as a central resource for developers to discover, compare, and select tools based on specific programming languages, licensing models, and integration requirements. The directory distinguishes itself by providing deep metadata for each listed utility, including community-driven popularity rankings, maintenance status, and deployment methods. By aggregating these tools into a single searchable index, it enables teams to identify solutions for enforcing coding standards, ma

This project is a comprehensive Python style guide and technical reference designed to promote the creation of clean, maintainable, and idiomatic code. It provides a set of opinionated guidelines and architectural patterns focusing on functional and declarative programming to reduce complexity and improve overall code quality. The guide establishes specific standards for naming conventions, module organization, and project layout. It emphasizes reducing object coupling by favoring modules and functions over deep class hierarchies and offers technical standards for writing docstrings and marku

Flow is a JavaScript static type checker and AST parser that identifies type errors and prevents runtime failures through static annotations. It functions as a code intelligence engine and a static analysis linter to identify unsafe coding patterns and enforce consistency across a codebase. The project includes a type annotation stripper that removes static type signatures from source code, ensuring the resulting JavaScript is compatible with any runtime environment. It also provides a parser that converts typed JavaScript into an abstract syntax tree conforming to the ESTree specification.

This project is a comprehensive set of standards for the Swift ecosystem, providing a code style guide, API design standards, and a memory management guide. It establishes standardized naming and formatting rules to ensure consistent and maintainable source code. The project includes a linting configuration used by automated tools to detect and enforce syntax patterns. These rules are designed to standardize code style and can be integrated into build phases to block commits with formatting errors. The guidelines cover a broad range of development capabilities, including the use of access mo

This project is a collection of guidelines and best practices for the Go programming language, providing a comprehensive style guide and set of programming standards. It establishes a framework for writing maintainable and performant source code through standardized naming, structuring, and organizational conventions. The guide focuses on specific patterns for concurrency, error handling, and performance optimization. It details methods for managing goroutine lifecycles to prevent race conditions, designing structured error wrapping and routing to maintain observability, and implementing memo

This project is a collection of engineering guidelines and best practices for writing readable and maintainable JavaScript source code. It serves as a clean code guide and refactoring manual to help developers improve the structure of their codebases. The repository provides a reference for applying SOLID principles to reduce coupling and enable extensions without modifying existing logic. It includes a naming convention standard for using explicit, searchable identifiers and a guide for asynchronous patterns to replace nested callbacks with clearer execution flows. The guidelines cover soft

Overcommit is a Git hook manager and pre-commit validation framework designed to automate the execution of scripts and checks during various Git events. It serves as a workflow automation tool that ensures code quality and project standards are met before changes are committed or pushed to a remote repository. The system distinguishes itself through a comprehensive YAML-based configuration that allows for detailed hook behavior control, including file execution filtering, conditional skipping, and the management of hook dependencies. It provides specialized roles such as a commit message vali

This project is a static analysis engine and type checker designed for PHP codebases. It evaluates source code structure and type annotations to identify potential bugs, type mismatches, and logic errors without executing the application. By parsing code into an abstract syntax tree and applying a rule-based validation framework, it enforces code quality and safety standards across a project. What distinguishes this tool is its sophisticated type inference engine, which models dynamic language features, magic methods, and conditional types to maintain accuracy even in unconventional code. It

This project is a static analysis runner designed to identify bugs, performance bottlenecks, and stylistic inconsistencies within Go codebases. It functions as a comprehensive quality assurance suite that executes multiple analysis tools concurrently to provide a unified diagnostic report. By parsing source code into a structured representation, the tool enforces coding standards, validates import structures, and ensures consistent formatting across entire projects. The tool distinguishes itself through its ability to automate the remediation of identified issues, applying programmatic fixes

This project is a collection of community-driven coding standards and best practices for developing maintainable Ruby on Rails applications. It serves as a style guide, architecture reference, and development guide to ensure consistency across a codebase. The guide provides technical recommendations for establishing naming conventions and architectural patterns. It specifically focuses on organizing models, controllers, and views to separate business logic from data persistence and user interface presentation. The documentation covers a broad range of capabilities, including RESTful API desi

This project is a static analysis engine designed to identify patterns, enforce coding standards, and automate code quality improvements in software projects. By parsing source code into structured abstract syntax trees, it enables deep programmatic inspection and the automated remediation of identified programming issues. The engine functions as a pluggable linting framework, allowing developers to extend its core capabilities through a modular architecture. Users can inject custom rules, parsers, and processors to support non-standard file formats or domain-specific logic. This extensibilit

Rushstack is a comprehensive toolset for managing large-scale TypeScript monorepos, providing a framework for build pipeline automation, dependency coordination, and static analysis. It functions as an incremental build orchestrator and management system designed to maintain consistency and performance across multiple packages in a shared workspace. The system distinguishes itself through an execution model based on directed acyclic graphs and content-hash-based incrementalism, which ensures only affected projects are rebuilt. It further optimizes development workflows via remote build artifa

gocode is a language server backend and autocompletion daemon for the Go language. It functions as a static code analyzer and symbol indexer that provides real-time identifier and symbol suggestions to text editors. The project utilizes a client-server daemon architecture to maintain a persistent background process, avoiding the overhead of reloading package metadata for every request. It employs a two-tier metadata caching system and parses compiled package binaries to enable fast symbol lookups and declaration retrieval. The system covers broad capability areas including context-sensitive

Larastan is a static analysis tool for PHP and a specialized extension for PHPStan. It serves as a code analyzer designed to detect bugs and architectural issues within Laravel applications by analyzing source code without executing it. The project provides framework-specific rule sets and specialized type-inference to handle the unique patterns and logic used in the Laravel ecosystem. This allows for more accurate error detection and type checking than generic analysis tools. The tool includes systems for managing legacy code debt through error baseline tracking and regex-based error suppre

Open-SWE is an asynchronous software engineering agent and orchestrator designed to automate end-to-end coding tasks and pull request reviews. It functions as a middleware framework that coordinates long-running AI operations across multiple subagents, utilizing state persistence and human-in-the-loop oversight to manage complex workflows. The system is distinguished by its use of isolated remote Linux sandboxes for secure code execution and shell command processing. It features a webhook-driven integration platform that triggers automated engineering tasks via mentions and events in GitHub,

SwiftFormat is a tool for the Swift language that functions as a code formatter, linter, and refactoring utility. It automatically applies consistent style rules and visual formatting to source files to ensure a uniform appearance across a project. The project differentiates itself by providing both a command-line interface for batch processing and an Xcode extension for integration directly into the development environment. It includes specialized capabilities for modernizing legacy API usage, simplifying language constructs, and inferring formatting options by analyzing an existing codebase

Crab is a memory-safe systems programming language and ahead-of-time compiler designed for high-performance software. It utilizes a type system based on strict ownership and borrowing rules to prevent memory access errors at compile time. The toolchain includes an automated documentation generator that produces technical reference manuals and API guides by parsing structured source code annotations. It also features a dependency management tool to resolve external library graphs and ensure consistent project builds. The project covers software build automation, static type checking, and mult

Infer is a static analysis toolset for Java, C, C++, and Objective-C designed to detect memory leaks, null dereferences, and resource bugs. It functions as a multi-language bug finder that identifies race conditions, deadlocks, and memory safety issues by translating source code into a common intermediate representation for analysis. The project distinguishes itself through an inter-procedural data flow analyzer that tracks movement between sources and sinks to detect tainted flows and generate data flow graphs. It also includes a framework for verifying temporal properties and reachability u

This is a static analysis linter and code quality tool for Go. It analyzes source code to identify common coding errors, style mistakes, and inconsistencies with language conventions. The tool is designed for integration with text editors and integrated development environments, exporting linting results in formats that support quickfix menus. Its capabilities include Go static analysis and source code quality assurance across files and packages. The system utilizes a static analysis pipeline and rule-based pattern matching to identify structural patterns that violate predefined coding stand

This project establishes a collection of interoperability standards for the PHP ecosystem. It defines common technical specifications to ensure that separate software projects and libraries can work together without compatibility issues. The standards cover a variety of core domains, including specifications for class autoloading through namespace-to-path mapping, shared coding style guides for codebase uniformity, and common component interfaces for services such as logging and caching. It also defines shared specifications for network communication to ensure consistent interactions between

This project is a curated collection of best practices, coding standards, and style guidelines for writing C++ source code. It serves as a software engineering resource focused on improving code safety, maintainability, and performance. The resource covers multiple domains of C++ development, including safety engineering to reduce bugs and memory errors, as well as code optimization for increased efficiency. It provides a set of collaborative guidelines for consistent code formatting and structural patterns across projects.

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