This repository provides C# bindings for the SDL3 multimedia library through automated code generation. It processes SDL3 C headers via the c2ffi tool to produce an intermediate JSON representation, then applies user-provided overrides to generate idiomatic C# P/Invoke wrappers. The output includes two variants: SDL3.Legacy.cs targeting .NET Framework using DllImport with manual string marshaling, and SDL3.Core.cs targeting .NET 8+ using LibraryImport with custom marshallers for improved safety and performance. The bindings enable .NET applications to access SDL3's graphics, audio, input, GPU, and system functionality. While the generator is highly specialized for SDL3, it demonstrates sophisticated patterns in type resolution, struct layout handling, and marshaling strategy selection that could inform similar binding projects.
Integuru is a Python application that reverse-engineers API requests from browser traffic to generate runnable integration code. It takes a HAR file (HTTP archive) containing browser network requests and cookie data, then uses LLMs to analyze these requests to identify which endpoint performs a user-specified action. The system builds a dependency graph to determine what prerequisite requests are needed to gather dynamic parameters (like IDs, tokens), and finally generates Python code that can reproduce the action by making the necessary HTTP requests in the correct order. The architecture uses LangGraph for workflow orchestration, with specialized LLM-powered agents handling different aspects of the analysis (URL identification, dynamic parameter extraction, dependency resolution).
This repository is a Godot GDExtension that enables using Dart as a scripting language for the Godot game engine. It provides a C++ native plugin that embeds the Dart VM, a Dart runtime library (`godot_dart`) with FFI bindings and type wrappers, and a build runner package (`godot_dart_build`) for generating boilerplate code from `@GodotScript` annotations. A binding generator tool (`tools/binding_generator`) reads Godot's extension API JSON to produce Dart bindings for engine classes and built-in types. The repo includes two example projects: a 2D game tutorial and a networking demo. It is feature-rich but explicitly experimental, with partial support for debugging, hot reload, and editor integration, and acknowledges that performance optimization has not yet been performed. The architecture is a hybrid of C++ native extension and Dart packages with code generation pipelines, making it a complex but well-structured integration layer between the Godot engine and the Dart language.
Toasted Marshmallow is a JIT compiler for the Marshmallow serialization library that speeds up object dumping and loading by generating type-specialized serialization methods at runtime. It works by creating optimized serializers for instance objects, dictionaries, and hybrid objects (those with __getitem__), then using a proxy to adaptively select the best serializer based on input type patterns. The project includes a forked Marshmallow submodule to provide necessary hooks for JIT integration. Architecture-wise, it's a Python library with core logic in toastedmarshmallow/jit.py, utility modules for code generation and compatibility, and performance benchmarks. Entry points involve setting schema.jit = toastedmarshmallow.Jit on a Marshmallow Schema instance.
Honey Potion is a compiler framework that translates a subset of the Elixir programming language into eBPF (extended Berkeley Packet Filter) programs, targeting both tracepoints and XDP. The system works as an Elixir library (published on Hex as `honey`) where users write eBPF logic in Elixir using macros like `@sec`, `defmap`, and `fuel`. At compile time, `__before_compile__` triggers a pipeline: static analysis, optimization (constant propagation, dead code elimination, type propagation), AST-to-C translation, boilerplate generation, and C compilation via `make`/`clang`/`llc`/`bpftool`. The generated C code includes a custom runtime with heap, tuple pool, and string pool implemented using BPF maps to overcome eBPF's stack and memory constraints. The repository includes 20+ example programs (system monitors, packet filters, data structure demos) and a comprehensive benchmark suite comparing hand-written C eBPF programs to Honey-generated ones, supporting a published research paper. Although classified as an application (a compiler library), the project has strong research characteristics with reproducible artifact scripts, optimizer variants, and performance comparisons.
This is the original Yii framework (version 1.x), a high-performance component-based PHP web framework. The codebase implements a full MVC architecture with ActiveRecord ORM, caching system, internationalization, input validation, logging, and a code generation tool (Gii). It is designed for both web and console applications, with multiple demo applications (blog, hangman, phonebook) showcasing its capabilities. The framework is built around a component/behavior/event system that allows extensibility. However, the code is end-of-life (EOL) as stated in the README, receiving only security and PHP 7/8 compatibility fixes. The codebase shows its age: it uses PHP 5.2-era patterns (no namespaces, var declarations, no type hints), bundles several outdated third-party libraries (HTMLPurifier, Text_Highlighter, Text_Diff), and has a massive collection of auto-generated i18n locale data files. Despite these drawbacks, the core architecture is well-structured and demonstrates solid engineering from its era. It is not recommended for new projects but can serve as a reference for legacy maintenance or for studying the evolution of PHP frameworks.
This repository is a curated collection of recipes and tools for Go development, organized into categories such as testing, dependencies, code visualization, code generation, refactoring, errors, build, assembly, deployment, execution, monitoring, benchmarking, documentation, security, static analysis, and guides. The actual codebase is minimal: a Go module with a three-line main.go that generates the README.md from a structured YAML file (page.yaml) using the mdpage library. The primary value is the content itself, which serves as a reference for Go developers to discover and utilize various tools and techniques. The project is actively maintained, with up-to-date dependencies and a simple CI workflow for markdown link validation.
BosqueCore is a compiler and toolchain for the Bosque programming language, a research-oriented language emphasizing mechanized reasoning, deterministic execution, and safe-by-design programming. The repository implements a full compilation pipeline in TypeScript: a recursive-descent parser and lexer, a semantic type checker with advanced features (invariants, pre/post conditions, validated strings, numeric range types), an IR with monomorphization, and a C++ backend that generates garbage-collected, allocation-aware code. The CLI (`src/cmd/bosque.ts`) compiles `.bsq` files to C++ and produces executables via a Makefile build system. Extensive tests cover parser, typechecker, C++ emission, and runtime execution of sample programs (raytracer, nbody, binary tree). The architecture is cleanly split between frontend (AST, parsing, checking) and backend (IR, monomorphization, C++ emission), with a hand-written recursion-descent parser and a highly detailed type system. However, the codebase is a work in progress: many language features are explicitly unimplemented (tasks, switch, dispatch, multi-return, resource/env handling) with `assert(false, "Not implemented")` stubs, and large monolithic files (e.g., `parser.ts`, `checker.ts`, `flatten.ts`) concentrate complexity. The repository also includes a C++ runtime with a custom GC and allocators, plus a lexer/serializer for the BAPI IR format. As a research project transitioning toward practical use, it offers a unique, safety-focused language design but is not yet production-ready.
This repository contains documentation and promotional materials for the MyBatisCodeHelper-Pro IntelliJ IDEA plugin. The actual plugin source code is not included in this snapshot; only README files, documentation pages, screenshots, and a few template files are present. The plugin provides advanced MyBatis support including SQL auto-completion, database-aware code generation, method-name-to-SQL conversion, OGNL expression assistance, real-time SQL validation, and MCP (Model Context Protocol) integration for AI coding assistants. It is a commercial plugin with a free tier and a pro tier. The documentation describes features, installation, activation, and usage scenarios across both Chinese and English audiences.
Pythagora (GPT-Pilot) is an AI-powered development assistant that uses a multi-agent system to generate full-stack applications through conversational interaction. The system orchestrates specialized agents (Architect, Spec Writer, Tech Lead, Developer, Code Monkey, Troubleshooter, etc.) to collaboratively write code, run commands, test, and fix bugs based on user specifications. It features a template-driven code generator for various stacks (Vite React, Node/Express/MongoDB, etc.), a persistence layer using SQLAlchemy for project state and knowledge base, LLM provider abstraction (OpenAI, Anthropic, Groq, Azure), and a telemetry system for usage tracking. The architecture centers around a state manager that tracks project progress through epics, tasks, and iterations, with communication to a VS Code extension frontend via IPC socket. While the code demonstrates solid engineering patterns in its agent abstraction, template system, and LLM integration, the repository is no longer actively maintained, as evidenced by a historical security incident in the telemetry component that went undetected for 10 months due to lack of oversight.
GoPhantom is a Go-based Windows loader generator designed for security research. It creates executables that embed and decrypt payloads and decoy files while employing various evasion techniques to avoid detection. The application takes input files (decoy and payload), encrypts them, generates Go source code using templates that incorporate the encrypted data and selected security features, then compiles this code for Windows/amd64. The resulting executable can showcase the decoy file to the user while executing the payload through techniques like process injection, API hashing, direct syscalls, memory protection evasion, and module stomping to make malicious code appear as legitimate DLL code. The project is explicitly archived and no longer actively developed, as stated in the README.
This repository implements a React library for building forms based on GraphQL APIs, specifically designed to work with Apollo Client. The library provides a code generation CLI tool that extracts GraphQL mutation information and converts it to JSON Schema, along with a React component that renders forms and handles submission via GraphQL mutations. The architecture consists of: 1. A CLI tool (`lib/cli.ts`) for generating schema and type definitions from GraphQL endpoints 2. Core form logic in `lib/forms/` including the main `ApolloForm` component, utilities for schema processing, and rendering customization 3. Integration with React-jsonschema-form as the underlying form engine Key features include conditional fields, custom validation, theming support, and automatic JSON Schema generation from GraphQL schemas. The library demonstrates particular strength in its JSON Schema manipulation utilities, which handle complex operations like resolving $ref references and applying conditional logic to schemas.
This is the Anko library for Android, a Kotlin DSL that provides type-safe builders for UI layouts, SQLite queries, intents, dialogs, async tasks, logging, and other common Android patterns. The repository additionally contains a code generator (using ASM to parse Android SDK classes) that produces extension functions for views, properties, listeners, and services per API level, and an IntelliJ/Android Studio plugin that includes XML-to-Anko conversion, live preview of DSL layouts, and refactoring intentions. The library is officially deprecated (see GOODBYE.md) in favor of Jetpack Compose, Splitties, and Android KTX; the last commit was in 2019. The codebase is well-structured overall, but the generated files are massive and repetitive, and the library has not kept pace with the Android ecosystem (e.g., still uses android.support libraries, GlobalScope for coroutines, and targets SDK versions up to 28). Reusable components include the static commons (Logging, Async, Intents, AlertBuilder), the code generator's class tree and rendering pipeline, and the SQLite query builders.
FastAdmin is a PHP-based rapid admin panel generator built on the ThinkPHP framework and Bootstrap/AdminLTE frontend. It provides a complete backend management system with Role-Based Access Control (RBAC), automatic CRUD code generation from database tables, a plugin/addon ecosystem, file upload with chunking support, API documentation generation from annotations, and multi-language capabilities. The architecture follows a monolithic MVC pattern with separate admin, API, and frontend modules, all sharing a common library layer. While functionally comprehensive and widely used (1926 stars, 607 forks), the codebase exhibits significant technical debt: uses outdated frontend frameworks (Bootstrap 3, AdminLTE 2.3.7, jQuery 3.7.1 with hacks), relies on weak password hashing (md5), depends on deprecated PHP extensions (mcrypt), and contains deeply coupled ThinkPHP-specific components. No unit tests are present in the file tree. The project appears to be in maintenance mode with low recent commit activity and open issues. It serves as a practical but dated example of an admin panel framework.