Awesome GitHub RepositoriesType Checking

mypy is a static type checker for Python that analyzes source code to detect type errors and inconsistencies without executing the program. It functions as a static analysis tool and type inference engine, providing a gradual typing system that allows type hints to be added to a codebase incrementally while maintaining compatibility with dynamic typing. The project distinguishes itself through a combination of performance and precision features. It utilizes a daemon-based incremental checking system and multi-process parallel analysis to manage large codebases, supported by binary cache persi

This project is a high-performance static type checker and comprehensive development toolkit for Python. It functions as a core analysis engine that identifies type inconsistencies and enforces code correctness, while simultaneously providing a language server implementation to deliver real-time diagnostics and intelligence directly within development environments. The tool distinguishes itself through a parallelized execution engine that maximizes performance across large-scale codebases and monorepo structures. It supports gradual type adoption, allowing developers to integrate type checkin

ts-node is a TypeScript execution engine and just-in-time transpiler for Node.js. It enables the direct execution of TypeScript files by converting them to JavaScript on the fly, removing the requirement for a manual pre-compilation build step. It also provides a TypeScript read-eval-print loop for evaluating expressions and testing code snippets in real time. The project integrates with the Node.js module system as a loader hook to resolve and load files using native import syntax. It features a pluggable compiler interface that allows the use of external transpilers to accelerate execution

is.js is a JavaScript validation library and data type checker. It provides a suite of utilities to verify whether variables are primitives, arrays, functions, or specific object types. The project allows for the implementation of custom validation logic and the use of naming namespaces to override default rules and regular expressions. It covers a broad range of validation capabilities, including numeric arithmetic properties, date and time analysis for relative and absolute ranges, and string format verification for patterns such as emails, URLs, and IP addresses. The library also includes

This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

Pyre is a high-performance static type checker and analysis tool for Python. It identifies type errors and ensures type safety without executing the program, utilizing a static type inference engine to maintain consistency across functions. The project is distinguished by an incremental type analysis engine that operates as a background daemon. This system monitors filesystem changes to re-validate only modified parts of a project, reducing the time required for repeated analysis. It also includes a static analysis security tool that uses taint analysis to track untrusted data flows and ident

Anomalib is a PyTorch-based library for visual anomaly detection, offering a modular framework, a comprehensive model zoo, and a benchmarking suite designed for industrial defect detection. It provides a wide range of algorithms—including generative, discriminative, teacher-student, and vision-language approaches—that support unsupervised, few-shot, and zero-shot settings. The library enables deployment through model export to ONNX and OpenVINO for edge devices, and includes a no-code web application for training and inference. It also features a command-line interface for orchestrating multi

attrs is a Python library that automatically generates initialization, representation, equality, hashing, and ordering methods from declarative class attribute definitions. At its core, it provides a class decorator metaprogramming framework that intercepts class creation to rewrite the class body, producing dunder methods without manual boilerplate. The library includes a comprehensive attribute validation toolkit with built-in validators for type checks, range constraints, regex matching, length limits, and logical composition of validation rules. The library distinguishes itself through it

stc is a TypeScript type checker implemented entirely in Rust, designed to validate type correctness in TypeScript source code with native performance and memory safety. It operates as a no-emitting type validator, meaning it checks types only and does not produce JavaScript output, reducing overhead compared to a full compiler. The checker is built around a zero-false-positive design, reporting only errors that are provably certain from the type system, prioritizing correctness over speculative warnings. The tool distinguishes itself through parallel file processing, analyzing source files c

Tortoise ORM is an asynchronous object-relational mapper for Python that mirrors Django's model and queryset API while running on asyncio. It defines database tables as Python classes with typed fields and supports foreign key, many-to-many, and one-to-one relations, providing a chainable query API for filtering, annotating, grouping, and prefetching related objects without blocking the event loop. The ORM includes a built-in migration engine that detects model changes, generates migration files, and applies or reverts schema changes through a command-line tool. It connects to PostgreSQL, MyS

Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications. The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize executi

Monty is a sandboxed execution environment designed primarily for running Python code generated by AI models. It provides a secure, isolated runtime that blocks host access, enforces resource limits, and supports pre-execution type checking against built-in type hints to catch signature mismatches before code runs. The sandbox can persist its interpreter state at external function calls, allowing execution sessions to be serialized, stored, and later resumed from a file or database. What distinguishes Monty is its combination of stateful, resumable execution with multi-language native embeddi

Pyrefly is a static type checker for Python that operates as a language server, delivering real-time diagnostics, completions, and navigation in any editor supporting the Language Server Protocol. It also performs static tensor shape analysis, using symbolic dimension variables and arithmetic to verify shape consistency in deep learning models without runtime execution. Beyond core type checking, Pyrefly supports gradual adoption workflows: it can generate a baseline of known errors so only new issues are reported, migrate configuration from other type checkers, and automatically suppress exi

This project is a Language Server Protocol implementation for PostgreSQL that provides autocompletion, syntax diagnostics, and type checking for SQL and PL/pgSQL. It functions as a database schema validator and a static analysis engine designed to detect security vulnerabilities, performance bottlenecks, and dangerous migration patterns in database scripts. The server differentiates itself by using live database connections to provide schema-aware intelligence, allowing it to verify that tables, columns, and data types actually exist. It performs static analysis on procedural functions to det

Typeshed ist eine Sammlung statischer Typdefinitionen und Stubs für die Python-Standardbibliothek und Drittanbieter-Pakete. Es dient als standardisierte Ressource für statische Analysetools und integrierte Entwicklungsumgebungen (IDEs), um die Korrektheit von Code zu validieren und typbasierte Code-Vervollständigung bereitzustellen, ohne den ursprünglichen Quellcode der Bibliotheken zu verändern. Das Projekt konzentriert sich auf die Erstellung und Wartung externer Type-Hint-Dateien, die Typannotationen von der Laufzeitimplementierung trennen. Es nutzt ein System zur Versionierung und zum Mapping dieser Stubs auf spezifische Versionen von Laufzeitpaketen, um die Kompatibilität zu wahren. Das Repository enthält eine Validierungssuite, um die Genauigkeit dieser Definitionen sicherzustellen. Dies umfasst die Validierung von Laufzeit zu Stub, um Diskrepanzen zwischen deklarierten und tatsächlichen Typen zu identifizieren, die Überprüfung der Verzeichnisstruktur sowie Regressionstests, um die Wiedereinführung bekannter Typ-Checking-Fehler zu verhindern.

Pytype ist ein Tool zur statischen Code-Analyse und eine Typinferenz-Engine für Python. Es fungiert als statischer Typ-Analysator, der Typ-Diskrepanzen erkennt und Typ-Annotationen verifiziert, ohne dass vollständige manuelle Hinweise erforderlich sind, und dient gleichzeitig als Typ-Stub-Generator zur Erstellung eigenständiger Definitionsdateien. Das Projekt zeichnet sich dadurch aus, dass es Variablen- und Funktionstypen durch eine Analyse von Codemustern und Zuweisungen automatisch bestimmt. Diese Inferenz-Engine ermöglicht eine strukturelle Code-Verifizierung und die Generierung von Typ-Stubs, die die Schnittstellen von Modulen und Funktionen beschreiben. Das System deckt breite statische Analyseoperationen ab, einschließlich struktureller Validierung von Klassenhierarchien und Funktionsaufrufen sowie Symbol-Tracking zur Erkennung von Namespace-Fehlern und Zugriffen auf ungültige Attribute. Es bietet zudem Typ-Prüf-Primitive zur Durchsetzung von Annotationen und ein Typsystem, das in der Lage ist, komplexe Datenstrukturen unter Verwendung von Unions und Optionals zu modellieren.

MonkeyType ist ein Laufzeit-Typ-Inferenz- und Analysetool für Python. Es sammelt tatsächliche Argument- und Rückgabetypen von Funktionsaufrufen während der Programmausführung, um die Erstellung statischer Typ-Annotationen und kompatibler Stub-Dateien zu automatisieren. Das System konvertiert erfasste Ausführungs-Traces in statische Typ-Hinweise, die direkt in Funktionsdefinitionen des Quellcodes eingefügt oder zur Generierung externer Typ-Stubs verwendet werden können. Dieser Prozess ermöglicht das Hinzufügen von Typsicherheit zu bestehenden Codebasen durch die Analyse realer Datentypen anstelle manueller Audits. Die Funktionen des Tools decken die Laufzeit-Typ-Sammlung, dynamische Typ-Inferenz und die Generierung statischer Typ-Definitionen ab. Es nutzt Quellcode-Modifikation und Call-Trace-Persistenz, um beobachtete Laufzeitmuster auf statische Signaturen abzubilden.

REFramework is a runtime modding framework for games built on the RE Engine, providing a C# plugin system with typed proxy code generation, a Lua scripting interface, an ImGui-based UI system, a runtime debugging toolkit, and a VR integration layer. At its core, it intercepts and modifies internal game engine functions and state at runtime through hooking and scripting APIs, enabling deep inspection and manipulation of live game objects. The framework distinguishes itself through typed proxy code generation that auto-creates C# interfaces from the game's type database, giving compile-time saf

Sorbet is a static analysis tool and type checker designed for Ruby codebases. It identifies type inconsistencies, potential bugs, and logic errors by examining source code without execution, helping to improve software reliability and maintainability in large-scale projects. The system employs a constraint-based type inference engine that evaluates expressions against defined annotations to validate data structures. To support rapid development, it utilizes incremental analysis and caching to provide feedback by processing only modified files and their dependencies. Beyond static analysis,

jscamp is a full-stack web development and education project focused on mastering JavaScript, TypeScript, and AI integration. It provides a structured curriculum and interactive exercises covering language fundamentals, frontend engineering, and backend API development. The project distinguishes itself through the implementation of autonomous AI agents capable of complex task automation, such as modifying files, managing servers, and executing API calls. It includes advanced AI development tools for conversational querying, real-time code suggestions, and automated repository analysis to gene