The Code Genome Project:
Every open source package, sequenced and assembled.
Open source packages are built into compiler-accurate Lossless Semantic Trees. Together they form a context registry where you can search, compare, and comprehend your dependencies.
Sequenced once, used three ways
Sequencing open source, one package at a time
Enterprise production applications run on 80-90% OSS dependencies. The slowest, most token-expensive thing your coding agent does is read bytecode to understand them.
Each open source package is built into a Lossless Semantic Tree that holds every signal the compiler sees: types resolved, call sites linked, dependencies mapped. The Code Genome Project stores these LSTs side by side, so the ecosystem can be queried as one.
Parsed once, details kept
Everything on the site reads from that stored form: the code search, the recipe catalog, and the tools an agent calls.
Search by type matching, not text matching
Search thousands of sequenced open source packages in milliseconds by type, symbol, and call site rather than by string. Because the trees are resolved, every match is a real reference rather than a lucky string, and you can see how any API, annotation, or pattern actually appears across open source.
Splicing the genome with deterministic programs.
Recipes are deterministic programs that recognize a target by its resolved type and rewrite it precisely. Written once and validated, recipes then run identically across one repository or a hundred thousand, whether the job is migrating a framework, patching a CVE, or enforcing a standard.
Recipe packages are available for download and use based on licensing terms.
All of open source at your agent’s fingertips
A remote MCP server opens the OSS Code Genome to coding agents. The Genome is growing to encompass all the world’s provably used open source code. We are exposing this to your agents via MCP with various tools to search, compare, and comprehend/prethink across thousands of open source packages and dependencies, resolved through the type system rather than matched as text.
The same tools, inside your estate.
The Code Genome Project runs on open source. The same sequencing, search, and recipe execution run inside enterprise code estates on the Moderne Platform, on private code.
The Code Genome Project, in brief
The Code Genome Project is a public index of the world’s open source, parsed into type-attributed, format-preserving Lossless Semantic Trees and served as code search, a recipe catalog, and a remote MCP server.
The Code Genome Project is a public index of the world’s open source, built and operated by Moderne as a public benefit product. It parses open source into Lossless Semantic Trees, so types, references and call relationships are resolved rather than guessed at from text. The same index backs code search on the site and a remote MCP server for coding agents.
A Lossless Semantic Tree, or LST, is a representation of source code that is both type-attributed and format-preserving: types are resolved and call sites are linked, and the original formatting and comments survive. It is what the corpus is built from, and it is why a zero result here is a verified zero rather than a query that failed to match text. The Lossless Semantic Tree page covers how it is produced and what it resolves.
Text search returns every line containing a string, which includes comments, documentation, unrelated classes and shadowed names. The Code Genome Project resolves the query against the type graph, so a reference is a reference because the types resolved. Search runs on Moderne Trigrep, a trigram index generated from stored Lossless Semantic Trees rather than from raw source, which is how it carries type information into the index.
Publicly available open source packages. The index grows from real usage rather than a fixed crawl list: we proactively discover packages by mapping the dependencies in use across our app tenant, and would do the same across customer repositories. Packages we haven’t seen are indexed the first time someone or some agent reaches for them, and an agent can request a missing package through the MCP server.
Most connect through the remote MCP server, which exposes the index as a set of tools rather than a single search box. An agent can find types and methods, look up implementations of an interface, pull real usage examples, and compare two versions of a package. Each of those resolves through the type system, so an agent can follow a call into a dependency, see the real type on the other side, and check how an API is actually used across the corpus before it writes anything.
Searching the open source packages and browsing the recipe catalog are open on codegenomeproject.org. Recipe licensing varies, and every entry in the catalog names the license that applies to it. OpenRewrite recipes are Apache 2.0 and free to run. Some Moderne recipes are under the Moderne Source Available License or are proprietary, and those are free to read but need a license to run at scale.
Moderne, as a public benefit product. Moderne is the company behind OpenRewrite, the open source ecosystem for automated source code refactoring, and builds what sits underneath the site: the parsers that produce Lossless Semantic Trees, the serialized form they are stored in, the Trigrep index layered over them, and the engine that runs recipes across them at scale. The corpus itself is the open source community’s code, published under the licenses its authors chose.