Projects sharing features with Hybridclr

KBEngine is a distributed game server engine and backend infrastructure designed for massively multiplayer online environments. It provides a multi-process architecture to handle high player concurrency and real-time interactions within a shared virtual world. The system features a scriptable game logic framework that combines a high-performance core with a high-level scripting language. This allows for game behavior modifications through a hot-fixable runtime that updates logic without requiring server restarts. The engine manages server scaling via dynamic load balancing across multiple ha

LuaViewSDK is a cross-platform UI engine and framework that uses a Lua-based scripting engine to render native user interfaces across multiple mobile operating systems. It functions as a dynamic UI orchestrator, separating interface logic from the underlying operating system to allow for the creation of native views driven by scripts. The system features a bidirectional native scripting bridge for exchanging data and triggering functions between the script runtime and native platform APIs. It also includes a Lua game runtime capable of executing interactive graphics and lightweight games thro

es-toolkit is a JavaScript utility library and TypeScript data transformation toolset designed as a high-performance alternative to traditional utility suites. It serves as a tree-shakable module library and a compatibility layer for those migrating from legacy dependencies by mirroring established function signatures. The project is specifically optimized for AI code generation, providing structured documentation and specialized skill sets to improve the accuracy and discoverability of its functions for AI coding assistants. Its architecture focuses on a zero-dependency core and modular expo

Remeda is a type-safe functional utility library for TypeScript designed for building data transformation pipelines. It provides a toolkit of helper functions for manipulating arrays and objects while maintaining strict type integrity throughout the process. The library is characterized by its support for both data-first and data-last calling styles. It utilizes lazy evaluation to process data collections, evaluating transformations only when the final result is requested to avoid creating intermediate collection copies. The toolkit covers collection manipulation, function composition, and t

This project is a structured Rust programming curriculum and systems programming course designed to take learners from beginner to expert levels. It provides a comprehensive set of training materials focused on mastering the core syntax, idioms, and technical foundations of the Rust language. The project features a specialized language transition framework that maps concepts from C++, managed languages, and dynamic typing to Rust idioms. This allows developers from different ecosystems to translate architectural patterns and memory models into idiomatic Rust. The training covers a broad rang

This project is a comprehensive library of fundamental computer science algorithms and data structures implemented in Kotlin. It serves as a toolkit for software engineering proficiency, providing a collection of standard computational techniques designed to operate on any data type through the use of language-level generics. The library distinguishes itself by emphasizing educational clarity and type-safe implementation. It utilizes interface-based abstractions to decouple algorithmic logic from specific data structures, while employing recursive problem decomposition and immutable state pat

Cello is a programming language extension for C that provides a higher-level implementation of the language. It integrates an object-oriented framework, an automated garbage collection system, and a runtime reflection library to enable dynamic type inspection. The project implements a structured system for object orientation within C, including support for classes, type classes, and polymorphism. It includes a runtime exception handling system to intercept execution errors and initiate recovery procedures. The framework further provides generic programming capabilities for creating reusable

Slang is a shader compiler framework that combines a modular shading language with automatic differentiation, multi-target code generation, and an intrinsic mapping and extension system. At its core, Slang provides a differentiable shader compiler that automatically generates forward and backward derivative propagation for functions with control flow, enabling gradient-based optimization in graphics. The framework also includes a fully featured shader language with modules, generics, interfaces, and separate compilation, all designed for building reusable shader libraries. From a single source

This project is a structured educational course and interactive tutorial designed to teach the TypeScript type system. It functions as a coding sandbox where users learn through a series of guided exercises and challenges that are verified using an automated local test runner. The curriculum covers a progression of skills starting with basic typing fundamentals and core language patterns. It advances into generic abstractions, complex type transformation techniques, and advanced type programming. The material also includes practical applications of software engineering patterns, such as bran

Pytype is a static code analysis tool and type inference engine for Python. It functions as a static type analyzer that detects type mismatches and verifies type annotations without requiring full manual hinting, while also serving as a type stub generator for producing standalone definition files. The project distinguishes itself by automatically determining variable and function types through an analysis of code patterns and assignments. This inference engine allows for structural code verification and the generation of type stubs that describe the interfaces of modules and functions. The

Donut is a toolset for loading and executing payloads in memory, featuring a position-independent shellcode generator, an in-memory payload injector, and a .NET assembly loader. It is designed to convert executable files and scripts into shellcode that can be executed within the memory space of a remote process without writing files to disk. The project specializes in security evasion through memory-based patching and payload obfuscation using symmetric block ciphers and compression. It includes a remote payload stager to retrieve encrypted modules from HTTP or DNS servers during runtime, red

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

OffensiveNim is a red teaming framework and post-exploitation toolkit developed in Nim. It provides a collection of low-level primitives and a Windows API wrapper designed for offensive security operations, including malware development and shellcode loading. The project focuses on evasion and obfuscation through techniques such as API unhooking, direct system calls, and anti-debugging mechanisms. It features diverse payload delivery methods, including reflective binary loading, the execution of .NET assemblies via CLR hosting, and various shellcode injection techniques using fibers, COM obje

Reason is a strongly typed functional language and multi-target compiler designed to produce either JavaScript for web environments or native machine code for operating systems. It serves as an OCaml-compatible language that shares an abstract syntax tree with OCaml, providing a practical syntax for the OCaml ecosystem. The project functions as a type-safe frontend language, incorporating JSX support to build user interfaces through structural elements that translate into type-safe function calls. It enables deep integration with the JavaScript ecosystem, allowing the use of existing librarie

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

Dexposed is a set of runtime tools and engines designed for dynamic patching, framework interception, and code instrumentation on Android devices. It functions as a hooking framework and instrumentation tool used to load custom code into running processes to alter logic without modifying the original bytecode. The project enables the interception and modification of method behavior within both Android applications and the system framework. It specifically provides capabilities for bypassing operating system limitations by overriding framework calls and applying hot patches to live processes w

Frege is a purely functional programming language that compiles to JVM bytecode, providing Haskell-like semantics for the Java platform. It is built around a Haskell-inspired compiler that implements non-strict evaluation and a static type inference system to ensure data immutability and prevent side effects. The project distinguishes itself through a sophisticated type system featuring rank polymorphism, type-class based dispatch, and static purity enforcement. It includes a JVM language bridge and a foreign function interface that map Java classes and interfaces into functional types, allow

pysheeet is a technical reference library providing a curated collection of code snippets and implementation patterns for advanced Python development, system integration, and high-performance computing. It serves as a comprehensive guide for implementing low-level network programming, native C extensions, and asynchronous and concurrent programming. The project provides specialized frameworks for the development and deployment of large language models, including tools for distributed GPU inference and high-performance serving. It also includes detailed patterns for high-performance computing

This project is a comprehensive guide and educational resource for the TypeScript language. It covers the fundamental principles of the language, including its structural type system, static type analysis, and the process of transpiling typed source files into JavaScript. The material details how to model complex data and reusable type logic using generics, conditional types, and mapped types. It also explains the use of declaration files to provide type safety for external JavaScript libraries and the integration of type checking into existing JavaScript projects via JSDoc annotations. The

This repository serves as the programming language design repository for C#, containing the official language specification and the technical standards governing its grammar, type safety, and memory management. It functions as a collaborative space for the formal design and evolution of the language. The project manages a community-driven evolution process, utilizing a public proposal backlog to debate and adopt new features. This involves formal syntax prototyping and the engineering of the type system to refine the language's behavior and implementation. The scope of the specification cove

jvm-sandbox is a bytecode instrumentation framework and plugin container for the Java Virtual Machine. It acts as a runtime application modifier that enables the injection and modification of bytecode in a running process without requiring an application restart or changes to the original source code. The system provides a non-invasive aspect-oriented programming framework to intercept method execution and alter behavior in live processes. It functions as an isolated environment for functional modules, employing a custom class loader hierarchy to prevent dependency conflicts between plugins a

This project is an interactive programming education resource and tutorial designed for learning the Rust programming language and systems programming concepts. It provides a collection of runnable and editable code examples that serve as a practical reference for language syntax and implementation. The resource features an interactive code sandbox that allows users to execute and test code snippets in real time. It emphasizes the verification of technical accuracy by executing embedded code blocks during the build process to ensure all examples remain functional. The content covers a compre

Atlas is a modularization system and dynamic component framework for Android. It functions as a class isolation layer and incremental update engine, allowing application logic and resources to be decoupled into independent bundles that are loaded at runtime. The project distinguishes itself by providing physical bundle isolation through custom class loaders to prevent dependency conflicts and bypass method count limits. It enables the deployment of remote components and incremental patches, using bytecode diffs and resource patching to update specific application parts without requiring a ful

ET is a C# game server framework and distributed actor model runtime designed for large-scale multiplayer environments. It provides a comprehensive toolkit for building distributed game backends, incorporating a multiplayer network transport layer and a specialized suite for game AI and pathfinding. The framework is distinguished by its use of a distributed actor model to scale processing across multiple threads and servers, utilizing isolated actors for state management and messaging. It features a unified codebase architecture that allows shared logic between the server and client, enabling

Pyarmor is a toolset for protecting Python software through source code obfuscation, bytecode protection, and binary compilation. It functions as a code obfuscator, bytecode protector, and binary compiler designed to prevent reverse engineering and unauthorized access to Python scripts and packages. The project distinguishes itself by providing a comprehensive software license manager that enables hardware-bound licensing. This allows developers to lock script execution to specific physical devices or virtual machines and enforce strict expiration dates via encrypted runtime keys. Its broade

This project is a JavaScript code protection tool designed to transform source code into a version that is difficult for humans to read. Its primary purpose is to protect intellectual property and prevent reverse engineering by altering the original program logic. The tool employs several advanced techniques to hinder analysis, including control flow flattening and the injection of dead code. It can compile functions into custom bytecode executed by an embedded virtual machine and encrypt string literals to prevent static analysis of text. Additional capabilities include anti-debugging mecha

TubeArchivist is a self-hosted YouTube video archiving system and metadata indexer. It functions as a personal media library and download manager that allows users to create a searchable offline collection of videos, channels, and playlists. The system distinguishes itself by indexing subtitles, comments, and channel information for full-text search and retrieval. It features automated media synchronization to track subscriptions and playlists, ensuring new content is automatically queued and downloaded as it is published. The project provides a broad set of capabilities for digital asset ma