curlconverter is a command-line tool and library that converts curl commands into equivalent code snippets in over 30 programming languages and HTTP libraries. It features a modular architecture with a tree-sitter based Bash parser for robust curl command parsing, language-specific generators for target code production, and extensive test coverage. The tool handles complex curl features including authentication, headers, data uploads, multipart forms, proxies, and SSL options, producing runnable code in languages ranging from Python and JavaScript to Rust, Go, and specialized tools like Ansible and HTTPie.
Querydsl is a type-safe query DSL framework for Java and Scala, with compile-time code generation via annotation processing. It provides a fluent, strongly-typed API for constructing queries across multiple backends: JPA/Hibernate, SQL (with many dialects), JDO, MongoDB, Lucene, in-memory collections, and spatial data. The library uses a core expression tree (Expression, Path, Operation) and visitors for serialization to backend-specific languages (JPQL, SQL, MongoDB query, Lucene query). Code generation produces static Q-types from annotated domain classes, enabling IDE-friendly autocompletion and refactoring safety. The architecture is modular: querydsl-core provides the DSL foundation, querydsl-apt handles APT, querydsl-codegen offers generic code generation utilities, and backend-specific modules (e.g., querydsl-jpa, querydsl-sql) supply serializers and templates. Despite its breadth, the core design is clean and extensible, with well-defined interfaces for operators, templates, and visitors. Some modules (e.g., Lucene 3/4, Morphia) show lower activity and dual spatial library support (JTS old/new) indicates ongoing migration. Overall, Querydsl is a mature, highly-crafted library that significantly simplifies database querying in type-safe Java applications.
JavaCPP is a mature, annotation-driven library that provides efficient Java-to-C++ interoperability via JNI. It is not an application but a core infrastructure library used by hundreds of downstream projects (e.g., OpenCV, FFmpeg, TensorFlow bindings) to bridge Java and native C++ code. The system consists of a code generation pipeline (Parser, Generator, Builder) that reads Java annotations and C++ headers to produce JNI wrapper classes, a runtime layer (Loader, Pointer hierarchy) that manages native memory and library loading, and a multidimensional data access layer (Indexer package) optimized for scientific computing. The architecture is modular: build-time code generation (Maven plugin and CLI), runtime library loading with caching and platform detection, and a uniform pointer API with automatic deallocation via PhantomReferences. Key entry points are the Builder class (for build-time code generation) and the Loader class (for runtime library loading). The codebase is largely well-crafted, with reusable patterns like the Indexer factory pattern, PointerScope for deterministic resource management, and annotation-driven configuration. Some core components (Generator, Parser) are acknowledged as complex and messy, reflecting organic growth to handle real-world C++ headers. The repository maintains an extensive test suite and supports a wide range of platforms (Linux, macOS, Windows, Android, iOS, FreeBSD, embedded architectures).
Luban is a game configuration solution that transforms structured data (Excel, JSON, YAML, Lua, XML, etc.) into strongly-typed code and serialized data for multiple target languages (C#, Java, Go, C++, Rust, Python, TypeScript, Lua, etc.) and data formats (binary, JSON, protobuf, flatbuffers, msgpack, BSON, etc.). It is implemented as a .NET 8 console application with a plugin-based pipeline architecture: schema loading → data loading → validation → code generation → data export. The core engine (Luban.Core) provides extensible interfaces for custom loaders, validators, code targets, and data targets, all discovered via assembly attributes. Code generation uses Scriban templates with language-specific extensions, and data serialization employs a custom compact binary protocol (ByteBuf). The tool is widely used in game development for managing configuration data across engines like Unity, Unreal, Godot, and Cocos.
FishNet is a comprehensive Unity multiplayer networking framework providing a full client-server architecture with RPCs, sync types, prediction, scene management, observer conditions, and multiple transport backends (LiteNetLib, Synapse, Yak). It employs IL code generation via Mono.Cecil to auto-generate serializers and RPC stubs, achieving high performance and low bandwidth usage. The codebase is well-structured with extensive use of partial classes, pools, and utility patterns. It includes demos for authentication, prediction, collider rollback, and scene management. While the framework is tightly coupled to Unity, many utility components (e.g., object pooling, ring buffers, quaternion compression) are reusable in isolation and demonstrate strong engineering craftsmanship. The project is actively maintained with a large community and regular commits.
Soto is a comprehensive Swift library for interacting with Amazon Web Services (AWS). It provides auto-generated, type-safe, async/await client code for over 300 AWS services, covering compute, storage, databases, machine learning, analytics, and more. The SDK uses a code generation pipeline (soto-codegenerator) that reads Smithy model files from the official AWS SDK Go v2 repository to produce Swift service structs, request/response shapes, paginators, and waiters. Beyond generated code, Soto includes handcrafted extensions for S3 (multipart uploads, presigned POST/URLs), DynamoDB (custom Encoder/Decoder to/from AttributeValue), and credential providers built on Cognito Identity and STS. The library depends on SotoCore for HTTP client, signing, and middleware infrastructure. It supports Linux, macOS, iOS, tvOS, and watchOS via Swift Package Manager.
This repository provides a generic-based dependency injection framework for Go, called 'kod' (Killer Of Dependency), along with a CLI tool for code generation, component registration, and dependency graph validation. It features a rich interceptor chain for cross-cutting concerns (retry, validation, tracing, rate limiting, circuit breakers, etc.), and includes a comprehensive test suite and examples. The codebase also incorporates an extensive set of AI agent skills for software development workflows (grilling, code review, TDD, domain modeling) from the mattpocock/skills ecosystem. The primary value is the DI framework that leverages Go generics to provide compile-time safety for component wiring, with generated boilerplate code. The architecture is modular with clear separation of core, interceptors, internal utilities, and tests. It is actively maintained with modern Go features.
Go Blueprint is a CLI tool for scaffolding Go project structures with optional integration of popular web frameworks (Chi, Gin, Fiber, Echo, Gorilla, HttpRouter, standard library), database drivers (MySQL, Postgres, SQLite, Mongo, Redis, Scylla), and advanced features (HTMX/Templ, Tailwind CSS, React/Vite, WebSocket, Docker, CI/CD workflows). The tool operates both interactively (via a TUI built with Bubble Tea) and non-interactively via command-line flags. It generates a complete project skeleton including `go.mod`, `Makefile`, `.air.toml`, `.env`, server code, routes, tests, and Docker configuration. The architecture is a standard CLI application using Cobra, with a clear separation of concerns: flags parsing, UI components, template generation, and project file creation. The codebase is well-structured, modular, and includes comprehensive CI/CD pipelines (linting, integration tests via Testcontainers, release automation). It is a practical, production-ready tool for Go developers.
easyjson is a Go library and code generator that produces specialized, reflection-free JSON marshal/unmarshal code for Go structs. It achieves 4–5× faster serialization than the standard `encoding/json` by generating type-specific encoder/decoder functions at compile time. The architecture consists of a CLI tool (`easyjson/main.go`) that parses Go source files, extracts struct annotations (`//easyjson:json`), and generates `_easyjson.go` files implementing `easyjson.Marshaler`/`Unmarshaler` interfaces. The runtime library provides a fast JSON lexer (`jlexer`), writer (`jwriter`), buffer pool (`buffer`), optional types (`opt`), and helpers for unknown fields, string interning, and zero-copy parsing. The project includes extensive benchmarks comparing against ffjson, jsoniter, and go/codec, and a comprehensive test suite covering edge cases like omitempty, snake_case, embedded types, and custom key types.
OpenAgents Control (OAC) is a framework for managing, testing, and orchestrating AI coding agents. It provides a CLI tool (`oac`) to install, update, and manage agents, context files, and skills from a registry. The system includes a plugin architecture for OpenCode and a compatibility layer that converts agent definitions between OAC, Claude Code, Cursor, and Windsurf formats. A comprehensive evaluation framework tests agent behavior against critical rules (approval gates, context loading, stop-on-failure, delegation, tool usage) using YAML-defined test suites and timeline-based analysis. The repository is primarily a software development toolchain for AI-assisted coding workflows, with strong emphasis on deterministic safety rules and multi-agent coordination.
HybridCLR is a Unity Editor plugin and runtime library designed to enable native C# hot updates for games using the IL2CPP backend. It achieves this by modifying the IL2CPP runtime to support a hybrid AOT (Ahead-of-Time) and Interpreter execution model, allowing dynamic assembly loading without recompiling the native binary. The system operates through a deep integration with Unity's build pipeline, utilizing Editor-only build processors to analyze metadata, strip unnecessary AOT code, and generate necessary native bridges. Architecturally, the repository is split between Editor tools (metadata analysis, code generation, build hooks) and Runtime components (assembly loading, method dispatch). It relies heavily on native code patching (UnityHook) and custom binary parsing (UnityFS) to intercept and modify Unity's internal behavior. External dependencies include dnlib for IL metadata manipulation and embedded compression libraries (7zip, LZ4) for asset handling. While the solution is technically sophisticated, it carries significant maintenance risks due to its tight coupling with Unity's internal APIs and IL2CPP runtime internals. The codebase maintains compatibility across multiple Unity versions (2019-2023+) through version-specific build processors, but this creates a high surface area for breakage during Unity engine updates. It is a specialized tool for game development rather than a general-purpose library.
Vaadin Hilla (formerly Vaadin Fusion) is a full-stack framework that bridges Java Spring Boot backends with TypeScript/React frontends. Its core function is automatic, type-safe code generation: Java classes annotated with @Endpoint or @BrowserCallable are parsed into OpenAPI specifications, which are then used to generate TypeScript client stubs, form models (with validation constraints mapped from JSR-380 annotations), and reactive signal bindings. This eliminates the need for manual API contracts and provides end-to-end type safety between server and client. The framework also includes a file-based router, a CRUD layer (ListService, FormService) integrated with JPA repositories, and reactive full-stack signals for real-time data synchronization via WebSocket push. Architecturally, Hilla is a monorepo organized into Java backend packages (endpoint, engine-core, typescript-generator) and TypeScript frontend packages (generator-core, react-crud, react-form, file-router, react-signals). Build integration is provided through Maven and Gradle plugins that trigger code generation during the build lifecycle. The code generator follows a plugin-based pipeline where each plugin (backbone, model, signals, push, subtypes, transfertypes) processes the OpenAPI schema to produce specific TypeScript output. The frontend runtime includes a middleware-enhanced ConnectClient for HTTP calls, declarative authorization via @AnonymousAllowed/@RolesAllowed, and a full i18n system. Security is a first-class concern with CSRF protection, JWT support, and Spring Security integration demonstrated across multiple test applications. The system does not include data pipeline or research code; it is a production-ready application framework. Notable reusable artifacts include a clean validator pattern in lit-form, a generic CommandRunner interface for external process execution, tree-merging utilities in the file router, and the full-stack signal implementation that demonstrates a command-based reactive state pattern. The codebase is actively maintained with extensive integration tests, though some areas (snapshot tests, dual Lit/React support, Atmosphere push dependency) introduce maintenance complexity and potential drift risks.
This monorepo provides a Flutter plugin ecosystem for creating native home screen widgets on iOS (WidgetKit) and Android (Jetpack Glance). It consists of three core packages: `home_widget` (Dart API for data persistence, updates, scheduling, and background interactions), `home_widget_generator` (annotation-based code generation emitting SwiftUI and Kotlin code from `@HomeWidget` annotations), and `home_widget_cli` (command-line tool for scaffolding and patching native projects). The plugin handles cross-platform widget lifecycle, configuration, localized text, timed data, interactive clicks, image assets, and widget previews. Multiple example apps demonstrate features like configurable widgets, file sharing, lock screen widgets, and generator-based layouts. The architecture is a developer toolchain with a monorepo structure using Melos, extensive CI/CD workflows, and comprehensive unit and integration tests.
GirCore is a comprehensive C# binding generator and runtime library for GObject-based native libraries (GTK, GStreamer, WebKit, Cairo, etc.). It reads GObject Introspection (GIR) XML files and produces strongly-typed C# bindings with P/Invoke declarations, SafeHandle memory management, and high-level managed APIs. The architecture consists of a generation pipeline (GirLoader parses GIR, GirModel defines an interface-based intermediate representation, Generator applies fixers and renders C# code via a modular converter system) and a set of runtime libraries (GLib, GObject, Gtk, etc.) that provide safe wrappers, signal handling, subclassing support, and platform abstraction. Key entry points include the GirTool CLI for regeneration, Module.Initialize() for library initialization, and Roslyn source generators/analyzers for GObject subclassing and GTK composite templates. The project is pre-1.0 but actively used by several desktop applications and the .NET MAUI Linux backend.
The GodotSharp.SourceGenerators repository provides a set of Roslyn source generators designed to enhance the Godot Engine C# development experience. These generators inspect C# source code for specific attributes (such as `[SceneTree]`, `[AnimNames]`, `[AudioBus]`, etc.) and generate corresponding strongly-typed accessor code, eliminating the need for magic strings and improving compile-time safety. The project supports both Godot 3 and Godot 4 versions, with a clear migration path outlined in the documentation. The architecture follows a modular pattern where each feature (e.g., scene tree access, animation names) is implemented as a separate extension. Each extension consists of an attribute, a data model, a scraper to extract information from the project and source files, a source generator that uses Scriban templates to produce C# code, and the template itself. Shared utilities handle common tasks such as path resolution, string manipulation, and unique ID generation, promoting code reuse and consistency across generators. The repository includes extensive test suites for both Godot 3 and 4, validating the generated code against various scenarios including inheritance, same-name handling, nullable reference types, and edge cases. This ensures the generators remain robust despite Godot's evolving API. The project is actively maintained, with recent commits and a structured approach to handling breaking changes between versions.
go-instrument is a CLI tool that automatically instruments Go source files with OpenTelemetry trace spans. It parses Go AST, identifies functions that accept a `context.Context` parameter, and inserts span creation, defer, and optional error recording statements. It handles various edge cases: anonymous functions, build constraints (ignore/exclude), generated files, custom context/error parameter names, already-instrumented functions, and preserves original line numbers for panic stack traces via compiler directives. The tool is implemented as a reusable library with a clear separation between the generic AST processing engine (`processor` package) and the specific instrumentation strategy (`instrument` package), allowing custom instrumenters. The CLI frontend is minimal; the core logic is in the `processor` and `instrument` packages and is cleanly abstracted via an `Instrumenter` interface. The codebase is well-tested, includes fuzz testing, and uses current Go tooling.
OpenAPI Generator CLI is a Node.js/TypeScript command-line wrapper around the Java-based OpenAPITools/openapi-generator JAR. Despite using NestJS, it is not a server: NestJS provides a DI application context that wires a Commander CLI. On every invocation (main.ts → AppModule.onApplicationBootstrap), it reads openapitools.json, resolves a generator version (querying Sonatype's Solr search for the latest stable when unset), writes it back to config, downloads and caches the JAR — atomically, via temp file + rename — then asks the Java CLI itself (via `help` and `completion` output) what commands it exposes, registers them dynamically, and spawns `java -jar ... <command>` with inherited stdio. It supports HTTP(S) proxies, JAVA_OPTS, custom generator JARs (classpath merge), and a Docker execution mode. Beyond pass-through, the CLI adds value the raw Java tool lacks: a `version-manager` subcommand (list/set/remove tagged versions backed by an interactive table picker) and a config-driven batch generator in openapitools.json where named generators map glob patterns to invocations with placeholder tokens (#{name}, #{cwd}, #{relPath}, #{ext}, ...), executed concurrently (max 10 processes). The repo is an Nx single-app monorepo bundled into a shebang'd main.js and released via semantic-release; GitHub Actions CI runs lint, unit tests, and real Java-based E2E on Ubuntu and macOS. Unit test coverage is thorough across config, version management, command pass-through, and command construction. Genuinely clever parts: dynamic discovery of an external CLI's command surface, atomic binary caching, and a table-to-interactive-select UI. The warts: a ~100-entry hardcoded fallback version list embedded in source, a legacy root lib/index.js publishing script superseded by the webpack package plugin, leftover NestJS scaffolding (environment stubs, 'not a production server' comment), deprecated RxJS toPromise() usage, an ESLint root config that effectively ignores all files, and a Nix flake pinned to Node 18 while the package requires Node 22. It does what it claims and is actively maintained, but the residue keeps it from being exemplary.
This repository is a collection of Nx plugins for integrating various frontend frameworks (Svelte, Solid, Preact, Ionic/Angular, Ionic/React, Stencil, Capacitor, SvelteKit) with Nx workspaces. It provides generators for scaffolding framework-specific projects and components, and executors for running framework-specific build, test, and serve commands within Nx. The architecture follows a monorepo structure with framework-specific packages under `packages/` and a shared `@nxext/common` package containing reusable utilities for Vite integration, dependency management, and workspace modifications. Each plugin adheres to Nx's plugin architecture with clear separation between generators (code generation) and executors (task execution). The project demonstrates strong maintenance practices with version synchronization scripts, comprehensive testing (unit and E2E), and documentation generation tools.
napari-chatgpt (Omega) is an LLM-powered autonomous agent designed as a napari plugin for interactive image analysis. It enables users to interact with the napari viewer via natural language through a chat interface, either embedded in napari or via a web-based UI. The system processes user commands by leveraging LLMs (via LiteMind) to select and execute appropriate tools for tasks such as image loading, segmentation, denoising, widget creation, viewer control, web search, and code execution. The architecture centers around a plugin-contributed dock widget that launches a chat interface, which communicates with a FastAPI/WebSocket backend. The backend hosts the Omega agent, which uses a modular tool system where each tool (e.g., for file operations, segmentation, or web requests) inherits from a base class and is responsible for executing specific actions. The agent can iteratively refine its actions through dialogue, enabling complex workflows like 'segment nuclei and show measurement statistics'. Key external dependencies include napari (>=0.5), LiteMind, LLM provider libraries (OpenAI, Anthropic, Google), FastAPI, Qt bindings, and scientific libraries like scikit-image, Cellpose, and StarDist.
Gratatouille is a framework for building Gradle plugins using a functional programming approach. It processes Kotlin functions annotated with @GTask, @GPlugin, and @GExtension via KSP to generate complete Gradle plugin implementations including task classes, workers, entry points, and descriptor files. The framework enforces classloader isolation to prevent dependency conflicts and provides automatic build caching, parallel execution, and automatic task wiring. Generated code follows Gradle best practices with proper input/output annotations and up-to-date checks.