Stage 1
Mature working prototypes
Production-used packages where new contract and generation ideas are proven against real projects.
Make software intent explicit
before code is generated.
Codepot connects typed contracts, reusable template packs, safe generation, and language tooling. Use the mature OpenAPI and Jinja workflow today, follow the official codepotx runtime, and explore the final Codepot Lang platform.
codepot-openapi→codepotg→codepotx→codepot
One ecosystem
Proven packages, an official runtime, and a complete language platform
Codepot evolves features through three complementary stages. The mature prototype packages remain supported while validated ideas move into codepotx and then into the final Rust platform.
Stage 2
Official JavaScript ecosystem
The stable rewrite path: a frontend-neutral runtime with a thin CLI and room for web, editor, MCP, and embedded clients.
Stage 3
Final Codepot platform
The Rust language, compiler, runtime, CLI, LSP, extension, web tooling, and MCP integration that complete the long-term project.
Why Codepot
One project, clear responsibilities
Each package has a deliberate role. Contracts describe intent, template systems preserve real project conventions, runtimes coordinate safe work, and language tooling makes the same meaning available to editors and AI.
- codepot-openapi turns typed TypeScript contracts into portable OpenAPI and x-codegen metadata
- codepotg applies proven Jinja template packs to real OpenAPI-driven projects
- codepotx stabilizes validated ideas behind a typed, frontend-neutral JavaScript runtime
- codepotx-cli stays thin so terminal behavior never diverges from the runtime
- Codepot Lang gives software intent a strongly typed language implemented in Rust
- The codepot CLI, LSP, and extension share one compiler and diagnostic model
- Template packs preserve project-owned frameworks, folders, naming, and code style
- Planning, manifests, guarded cleanup, and dry runs keep generation reviewable
- Runtime operations can be reused by web, editor, MCP, desktop, and embedded clients
- AI agents receive structured intent instead of repeatedly guessing repository conventions
Feature maturity path
How Codepot evolves without abandoning working tools
New ideas can be proven in mature packages, stabilized behind the frontend-neutral codepotx runtime, and finally expressed through the Rust language and toolchain.
The supported TypeScript prototype validates authoring patterns against real APIs and emits standards-based OpenAPI plus generator-focused metadata.
The supported Python runtime consumes OpenAPI, builds a normalized model, and exercises Jinja template packs, write policies, diagnostics, and project tasks in real applications.
The official JavaScript rewrite separates contracts, authoring, templating, generation, platform adapters, and runtime operations behind stable typed artifacts.
codepotx-cli is only the terminal frontend. Web tools, editor extensions, MCP servers, desktop applications, and embedded Node.js clients can drive the same runtime operations.
The Rust language, standard library, compiler, IR, analysis host, formatter, CLI, LSP, and extension make software intent a first-class typed platform rather than a TypeScript-only configuration model.
Contracts, semantic artifacts, diagnostics, plans, and templates become shared material for human review, deterministic tools, and future AI integrations through Codepot MCP.
Workflows
Real files from contract to generated code
Each tab is loaded from a real source file in the website project. Edit the contract, CodepotG task, paths configuration, or Jinja template in the shared syntax-highlighted editor.
Who it serves
A shared foundation for teams, tools, and AI
Codepot keeps domain meaning and implementation patterns explicit, whether you are maintaining today's OpenAPI workflow or building the next generation of developer tooling.
API and platform teams
- Author typed OpenAPI contracts
- Share schemas and route intent
- Preserve x-codegen metadata
- Generate SDKs and application layers
- Keep API decisions reviewable
Template and product teams
- Reuse Jinja or Handlebars packs
- Preserve real project conventions
- Plan and preview generated files
- Protect edited and immutable files
- Control generation in each project
Tooling and AI builders
- Embed a frontend-neutral runtime
- Build CLI, web, editor, or MCP clients
- Use compiler-grade diagnostics
- Read target-neutral semantic artifacts
- Reduce repeated repository discovery
Craft the next layer
Choose the Codepot workflow that fits today
Build with the supported codepot-openapi and codepotg workflow, evaluate the official codepotx runtime, or follow Codepot Lang as the Rust compiler, codepot CLI, LSP, extension, web, and MCP platform come together.
Open source · MIT licensed
Framework and target-language neutral
Built for developers, tools, and AI agents