awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
mgechev avatar

mgechev/revive

0
View on GitHub↗
revive.run↗

Revive

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 via inline comments, excluding files from analysis, and extending the engine with custom analysis rules. Analysis results can be exported in multiple standardized formats for integration with external tools.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Code Quality Analyzers - Analyzes Go source code against configurable rules to identify style violations and potential bugs.
  • Static Code Analysis Tools - Implements a static analysis engine that scans Go source code for bugs and style violations without execution.
  • Analysis Integration APIs - Provides programmatic APIs to invoke the analysis engine directly within other Go applications.
  • Embeddable Analysis Engines - Integrate core logic directly into another application to perform programmatic code checks without using a command line interface.
  • Static Analysis Tools - Acts as a static analysis tool that automates linting and code quality checks for Go projects.
  • Customizable Rule Sets - Allows users to manage linting behaviors and severity levels through a structured external configuration file.
  • Go Source Code Analyzers - Performs static analysis on Go source files to detect mistakes and enforce style standards.
  • Style Linters - Provides a set of configurable rules to enforce coding styles and idiomatic standards in Go source code.
  • Go Quality Validators - Provides automated validation of Go-specific formatting and linting to maintain high code quality standards.
  • Embeddable Analysis Engines - Exposes the core linting logic as a library that can be imported and executed within other Go applications.
  • Linting Rule Configurations - Determines which analysis rules to execute and their severity via a structured external configuration file.
  • Static Analysis AST Parsing - Utilizes abstract syntax tree parsing to inspect Go source code structure and detect coding errors.
  • Advanced Code Inspection - Exposes the core linting engine as a library for programmatic code analysis within other Go applications.
  • Custom Lint Rule Plugins - Provides a plugin interface for adding custom lint rules beyond the built-in set.
  • Custom Lint Rule Definitions - Creating and applying project-specific analysis logic to enforce unique architectural constraints or internal coding standards.
  • Programmatic Source Analysis - Functions as an embeddable analysis engine providing an API for programmatic source code inspection.
  • Linter Rule Extensions - Enables adding project-specific checks by implementing a rule interface and integrating it into the engine.
  • Rule Interfaces - Defines a standard interface that each linting rule must implement for integration into the analysis engine.
  • Warning Suppressions - Implements mechanisms to ignore specific linting rules on individual lines of code.
  • Rule Suppression Comments - Supports inline source code comments to disable specific linting rules for targeted lines or blocks.
  • Quality Gates - Can be integrated into CI/CD pipelines as a quality gate to prevent non-compliant code merges.
  • Code Analysis and Linting - Fast, configurable, and extensible linter.
  • Code Analysis and Quality - Fast and configurable code linter.
  • Static Analysis and Linting - Fast, configurable linter for identifying style and performance issues.
5,524 stars·315 forks·Go·MIT·25 views

Star history

Star history chart for mgechev/reviveStar history chart for mgechev/revive

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Revive

These projects share indexed features with Revive. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • pycqa/flake8PyCQA avatar

    PyCQA/flake8

    3,760View on GitHub↗

    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

    Pythoncomplexity-analysisflake8linter
    View on GitHub↗3,760
  • ansible/ansible-lintansible avatar

    ansible/ansible-lint

    3,876View on GitHub↗

    ansible-lint is a static code analysis tool and linter designed to identify syntax errors and best practice violations within Ansible playbooks and roles. It functions as a quality gate for automation pipelines, scanning configuration files and scripts without executing the code to ensure reliability and consistency. The project distinguishes itself by acting as an automated code formatter that can correct identified linting issues and reformat files to meet community standards. It also serves as a dependency manager, automatically detecting and installing required roles and collections from

    Pythonansibleansible-dev-toolsansible-lint
    View on GitHub↗3,876
  • stylelint/stylelintstylelint avatar

    stylelint/stylelint

    11,484View on GitHub↗

    Stylelint is a static code analysis tool and linter for CSS and style-like languages. It identifies errors, enforces coding conventions, and operates as a PostCSS plugin to validate stylesheets during build pipelines. The project distinguishes itself through support for non-standard syntaxes, including preprocessor parsing for SCSS and Less, and the ability to extract and lint embedded styles from JavaScript, HTML, and template literals. It features an automated fixing system that programmatically corrects repairable styling violations to ensure consistency. The system provides a plugin arch

    JavaScript
    View on GitHub↗11,484
  • securego/gosecsecurego avatar

    securego/gosec

    8,866View on GitHub↗

    gosec is a static analysis security tool designed to scan Go source code for vulnerabilities and common coding flaws. It functions as a security analyzer that inspects the abstract syntax tree to identify insecure function calls, API usage, and potential security risks. The tool distinguishes itself by mapping detected vulnerabilities to Common Weakness Enumeration identifiers for standardized reporting and integrating with external AI models to suggest code fixes for identified issues. Its capabilities cover the detection of injection vulnerabilities, hardcoded credentials, weak cryptograph

    Go
    View on GitHub↗8,866
Compare all 30 related projects→

Frequently asked questions

What does mgechev/revive do?

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.

What are the main features of mgechev/revive?

The main features of mgechev/revive are: Code Quality Analyzers, Static Code Analysis Tools, Analysis Integration APIs, Embeddable Analysis Engines, Static Analysis Tools, Customizable Rule Sets, Go Source Code Analyzers, Style Linters.

Which projects share features with mgechev/revive?

Projects with overlapping indexed features include: pycqa/flake8 — Flake8 is a Python style checker and static analysis tool that identifies programmatic errors and violations of coding… ansible/ansible-lint — ansible-lint is a static code analysis tool and linter designed to identify syntax errors and best practice violations… stylelint/stylelint — Stylelint is a static code analysis tool and linter for CSS and style-like languages. It identifies errors, enforces… securego/gosec — gosec is a static analysis security tool designed to scan Go source code for vulnerabilities and common coding flaws.… checkstyle/checkstyle — Checkstyle is a Java static analysis tool and linter designed to identify and enforce coding standards and best… feross/standard — Standard is a zero-configuration static analyzer, linter, and formatter for JavaScript. It functions as a style guide…