Open-source alternatives to Typescript Go

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 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 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

Dependencies is a static analysis utility designed to inspect Windows portable executable files and map their library dependency hierarchies. It functions as a diagnostic interface for validating library imports and identifying the specific modules required for an application to execute on a Windows system. The tool distinguishes itself by performing deep binary analysis, including the resolution of complex Windows API set schemas and forwarded export redirections. It identifies libraries loaded on demand through delay-load module analysis and performs recursive traversal to map the full tree

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

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

This project is a community-driven style guide that defines standards for formatting and structuring Ruby code. It serves as a collection of language conventions and best practices intended to ensure that Ruby applications are written idiomatically and maintainably. The guide functions as a static analysis standard, providing a reference that automated linting tools use to enforce uniform coding patterns and structural rules. By mapping written guidelines to these automated configurations, it establishes a shared source of truth for code consistency. The scope of the project covers Ruby code

This project is a TypeScript library starter kit that provides a pre-configured development environment for building and publishing typed packages. It establishes a zero-config build pipeline to accelerate the creation of library projects. The toolkit includes a RollupJS bundle configuration to compile source code into optimized bundles with automatic type definition generation. It integrates a semantic release workflow to manage versioning and changelogs based on conventional commit messages, alongside a Jest testing framework suite for stability verification. The environment covers code qu

This project provides a comprehensive technical guide and set of best practices for authoring, configuring, and maintaining JavaScript and TypeScript libraries. It serves as a reference for developers to manage the lifecycle of reusable code modules, focusing on the standards required for distribution across diverse runtime environments and bundlers. The guide details the configuration of public API surfaces, the management of peer dependencies, and the implementation of multi-format build pipelines. It emphasizes techniques for optimizing package size and compatibility, including the use of

openapi-typescript is an OpenAPI TypeScript type generator and schema transformer. It converts JSON or YAML OpenAPI specification files into static TypeScript type definitions to provide end-to-end API type safety. The tool functions as a static type generator that transforms external API definitions into interfaces and types. It focuses on zero-runtime type enforcement, ensuring that data consistency is maintained via the TypeScript type system without adding overhead to production bundles. The project covers API type safety and schema conversion, facilitating the validation of request bodi

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

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

This project is a type-safe GraphQL client generator and TypeScript schema compiler. It transforms GraphQL schema definitions and operation documents into static TypeScript types to ensure compile-time validation and data consistency between an API and a frontend application. The system functions as a customizable GraphQL plugin framework. It uses a plugin-based architecture and a custom pipeline to generate tailored API clients and request functions, eliminating the need for manual type declarations. The project covers GraphQL client automation, type generation, and workflow optimization. I

Prisma is a type-safe database object-relational mapper that uses a declarative schema to map data models to relational and document databases. It provides a unified toolkit for data access, combining a database driver with tools for schema management and record manipulation. The project features a multi-database driver that standardizes interactions across PostgreSQL, MySQL, and MongoDB. It includes a system for tracking and applying structural schema migrations across different environments and a graphical user interface for browsing and editing database records. The system ensures data in

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

prettier-eslint is a command-line code stylist and JavaScript formatter that integrates Prettier and ESLint. It functions as a linter wrapper, coordinating a sequential pipeline of formatting and linting tasks to ensure source code is both aesthetically consistent and rule-compliant. The tool resolves conflicts between style guides and logic rules by executing linting fixes after formatting. It allows for a configurable formatting sequence to prioritize specific rules and can identify unformatted files to facilitate use in version control hooks. The project provides capabilities for automati

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

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

Plato is a JavaScript static analysis tool and code complexity visualizer. It computes complexity metrics and runs linting checks on JavaScript source code to evaluate codebase quality, presenting the results through a static analysis dashboard. The system aggregates linting data and technical metrics into timestamped reports. It specifically calculates cyclomatic and Halstead metrics to identify overly complicated files and assess the maintainability of a project. The tool provides capabilities for source code visualization, automated quality reporting, and maintainability assessment. It in

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

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.

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

PurifyCSS is a CSS unused style remover and payload optimizer that analyzes HTML and templates to identify and delete unused CSS selectors from stylesheets. It functions as a frontend build automation tool that integrates into development pipelines to automatically strip redundant styles and minify assets during the compilation phase. The tool provides specific optimization for single page applications, identifying and removing redundant CSS while ensuring necessary styles are preserved across dynamic views and states. The utility covers a range of capabilities including static content analy

This project is a JavaScript style guide and a set of coding standards designed to ensure codebase consistency. It provides a collection of best practices for writing maintainable and idiomatic code, focusing on variable naming, type checking, and execution context. The project serves as a static analysis guide, offering frameworks and guidelines for using linters and automated tools to identify bugs and verify code correctness before deployment. It establishes standards for formatting, syntax, and variable declarations to standardize code style across a project. The scope of the project cov

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

Puerts is a TypeScript runtime embedder and game engine scripting framework designed to integrate dynamic languages into low-level host applications. It functions as a high-performance cross-language API bridge, allowing developers to execute gameplay logic and editor scripts using TypeScript and JavaScript within a compiled host environment. The project distinguishes itself through a unified bridging API that supports pluggable scripting backends, enabling the selection or hot-swapping of different language engines to balance execution speed against binary size. It provides automated type de