Code Generation

oapi-codegen8.6k★

oapi-codegen turns OpenAPI 3.0 specs into Go code. Generate server boilerplate for Chi, Echo, Fiber, Gin, gorilla/mux, Iris, or net/http; generate API clients with custom request editors; or just generate types from your schemas. Apache 2.0, free, idiomatic Go output. No service to run; it's a code generator you invoke from your build. The strict server mode handles request and response marshaling automatically. Recent versions added import mapping so you can split a giant spec across packages, which actually matters when your API surface gets big. This is the standard for OpenAPI-first Go services. If you have a spec, you should be using this. Solo, small, large, all the same answer: free, run it as part of your codegen pipeline, save yourself days of boilerplate. The catch: OpenAPI 3.1 support is experimental, the release cadence is loose (pinning to commits is recommended for unreleased features), and the generated code aims for simplicity over refactoring, so you'll see some duplication. Implicit additionalProperties are also ignored by default. Read the docs before you assume your spec round-trips perfectly.

codeflow5.2k★

CodeFlow turns a GitHub repo into an interactive dependency map. Paste a URL or drag a folder, it renders the file graph in your browser, picks out singletons and factories and god objects, scans for hardcoded secrets, and gives you an A-F health grade. Runs entirely client-side. MIT. No install. No backend. Your code never leaves the browser unless you set a GitHub token to read private repos, and even then it stays in tab memory. There's a Vercel-hosted version you can use right now, or clone and run locally. The repo also ships a GitHub Action that drops an SVG health card on your README, recomputed every merge. For new engineers landing on a codebase: this is the fastest way to get oriented. For tech leads doing code review: the blast radius feature actually answers the question 'if I change this file, what breaks.' For anyone wanting a polished architecture diagram for a doc: works fine, but expect to clean up the export. It's a static analyzer, not a runtime profiler. Dependency edges come from imports, not from what actually executes. Dynamic dispatch, reflection, and string-based requires will fool it. Good for the shape of the system, not the truth of it.

mapperly4.2k★

Mapperly writes your .NET object mapping code at compile time. Moving data from a database entity to an API response object means a pile of tedious property assignments, and AutoMapper handled that for years using runtime reflection. Mapperly does the same job as a Roslyn source generator: declare a partial class with a Mapper attribute and the method signatures, and the implementation lands in your build. Apache 2.0, free, on NuGet. The wins are speed and debuggability. No reflection at runtime means mapping costs the same as hand-written assignments, and the generated code is plain C# you can step through and read in a diff. Mistakes become compile errors instead of production exceptions. AutoMapper's newer versions moved to commercial licensing, which sent a lot of .NET teams looking for exactly this. One package reference. Nothing to host, nothing to configure at runtime, no ops burden at any team size. The catch is that compile-time generation costs you runtime flexibility. Mapping shapes you only learn from data at request time is not what this is for, and complex custom conversions take more attribute wiring than the equivalent AutoMapper profile. You trade flexibility for a build that fails loudly instead of a request that fails quietly.

rewrite3.7k★

OpenRewrite automates the most tedious job in software maintenance: updating old code. Migrating to a new framework version, swapping out a dead library, patching a known security hole, normally that's a developer grinding through files by hand. OpenRewrite does it for you. You pick a "recipe" (a pre-written set of instructions for a specific change), point it at your codebase, and it rewrites the files while preserving your original formatting, so the diff is reviewable instead of a mess. The engine is Apache 2.0 and free, built by a company called Moderne. What makes it more reliable than find-and-replace is that it actually understands your code. It parses everything into a type-aware tree, so changes are context-aware, not blind text substitution. You run recipes through first-class Maven and Gradle plugins. Java is by far the deepest and most mature target; Kotlin, JavaScript and TypeScript, Python, and C# are supported but less complete. Running a recipe against a single repository is entirely free and needs no account. The work on your end is picking the right recipe, configuring it, running it, and reviewing what it produced, plus a learning curve if you want to author your own recipes. The paid layer, Moderne's platform, is about scale: running recipes across hundreds or thousands of repositories at once, with impact analysis and dashboards on top. So the honest split is that the thing that does the refactoring is free, and what you pay for is doing it across an entire organization's fleet with governance. Solo developers and small teams on a handful of repos: the free engine is all you need. Large teams drowning in multi-repo migrations are exactly who Moderne's commercial product targets. The catch is the gravity toward the paid tier. Single-repo, the free version is genuinely complete. But the moment your problem is organization-wide, the manual multi-repo workflow gets painful fast, which is by design. If you're mostly a Java shop with migration debt, this is a clear win. Outside Java, check that the recipes you need actually exist before counting on it.

gitreverse1.9k★

GitReverse takes a public GitHub repo and works backwards to the prompt that could have built it. It reads the structure, the README, and the metadata, then has an LLM write the kind of plain-English instruction you would hand Cursor or Claude Code to recreate the project. It now does the same trick on websites. A learning tool and a decent way to see how a finished codebase reads as a specification. Running it yourself is more work than the demo suggests. It is a Next.js 16 app you clone and configure: copy the env template, supply at least one LLM provider key from Grok, OpenRouter, Azure OpenAI, or Google AI Studio, then pnpm install and pnpm dev. A GitHub token, Supabase, and Stripe are optional depending on the features you want. The generated prompts are a starting point, not a blueprint. Reading structure and a README tells you what a project looks like from outside, which is not the same as knowing why it was built that way. Solo developers and people learning how projects are shaped get the most out of it. Teams will find it interesting rather than useful. The catch is the license, or rather the absence of one. This repository ships no LICENSE file, which under default copyright means all rights reserved: no permission to use, modify, or redistribute, whatever public availability suggests. Running the hosted demo is fine. Forking it is not, until the author adds a license.