Stop writing repetitive boilerplate by hand.

CodeGen is a fast, universal right-click template generator for VS Code and Antigravity IDE. Whether you are building mobile apps with Flutter / Dart, backend APIs with Laravel / PHP, web frontends with React or Vue, high-performance microservices with Go, or REST APIs with Python / FastAPI, CodeGen lets you scaffold production-grade, multi-file code directly inside any selected folder in seconds.

How It Works

1. Right-click any folder in your Explorer tree where you want your new files to live.
2. Select a template from the context menu (with dedicated submenus for each framework or a searchable universal picker) and enter your component name.
3. Instant scaffolding: Complete, typed, production-ready files are generated and opened automatically in your editor.

Visual Showcase

1. Explorer Context Menu

Right-click any folder to access the CodeGen menu with dedicated submenus for Flutter, Laravel, React, Go, Vue, Python, and a universal picker:

2. Searchable Template Picker

Run New from Template... (Ctrl+Shift+P / Cmd+Shift+P or via right-click) to filter and select from all available templates:

3. Generated Code Output

Scaffold single or multi-file templates complete with imports, syntax, and formatting:

Features

• Truly Universal: Built for multi-language development. Ships with rich presets for Dart/Flutter, Laravel/PHP, React, Go, Vue, and Python/FastAPI, and is easily extensible for any custom stack.
• 1-Click Generation via Explorer: Right-click folder -> CodeGen -> select template. Scaffolding is created directly where you clicked.
• 31+ Built-in Production Presets: High-quality presets ready to use out of the box across 6 major languages and ecosystems.
• Global Templates Directory (~/.codegen/templates): Store your personal scaffolds in one central global directory so they are accessible across all projects on your machine.
• Multi-File Scaffolding: Generate companion files (such as Component + CSS Module, Interface + Implementation, or Bloc + State) from a single user prompt.
• Smart String Case Transformations: Supports PascalCase, camelCase, snake_case, kebab-case, UPPER_CASE, and smart plurals (${NAME_PLURAL_SNAKE_CASE}, ${NAME_PLURAL_CAMEL_CASE}, ${NAME_PLURAL_PASCAL_CASE}).
• System & Timestamp Metadata: Automatically injects ${DAY}, ${MONTH}, ${YEAR}, ${HOUR}, ${MINUTE}, and ${USER}.
• IntelliJ Velocity Compatibility: Automatically parses legacy IntelliJ and Android Studio Velocity capitalization expressions.
• Safe Overwrite Protection: Warns you if target files already exist before overwriting.

Built-in Presets Reference

Dart / Flutter Presets (10)

Laravel / PHP Presets (6)

React / TypeScript Presets (3)

Go / Golang Presets (8)

Vue 3 Presets (2)

Python / FastAPI Presets (2)

Code Examples

Dart HTTP Service (VisionListService)

import 'package:dio/dio.dart';

class VisionListService {
  final Dio _dio;

  VisionListService(this._dio);

  Future<Response> fetchVisionList(String id) async {
    return await _dio.get('/api/vision_lists/$id');
  }

  Future<Response> fetchAllVisionLists() async {
    return await _dio.get('/api/vision_lists');
  }

  Future<Response> createVisionList(Map<String, dynamic> data) async {
    return await _dio.post('/api/vision_lists', data: data);
  }
}

Laravel API Controller (PostController)

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index(): JsonResponse
    {
        $posts = Post::latest()->paginate();

        return response()->json($posts);
    }

    public function store(Request $request): JsonResponse
    {
        $validated = $request->validate([
            'name' => ['required', 'string', 'max:255'],
        ]);

        $post = Post::create($validated);

        return response()->json($post, 201);
    }
}

React Component & Module CSS (UserCard)

import React from 'react';
import styles from './UserCard.module.css';

export interface UserCardProps {
  className?: string;
  children?: React.ReactNode;
}

export const UserCard: React.FC<UserCardProps> = ({ className = '', children }) => {
  return (
    <div className={`${styles.container} ${className}`.trim()}>
      <h2 className={styles.title}>User Card</h2>
      {children}
    </div>
  );
};

export default UserCard;

Go HTTP Handler (user_handler.go)

package handler

import (
	"encoding/json"
	"net/http"
)

type UserHandler struct{}

func NewUserHandler() *UserHandler {
	return &UserHandler{}
}

func (h *UserHandler) GetAll(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	_ = json.NewEncoder(w).Encode(map[string]interface{}{
		"success": true,
		"data":    []interface{}{},
	})
}

Go Gin Handler (product_handler.go)

package handler

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

type ProductHandler struct{}

func NewProductHandler() *ProductHandler {
	return &ProductHandler{}
}

func (h *ProductHandler) RegisterRoutes(rg *gin.RouterGroup) {
	group := rg.Group("/products")
	{
		group.GET("", h.GetAll)
		group.GET("/:id", h.GetByID)
		group.POST("", h.Create)
	}
}

func (h *ProductHandler) GetAll(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    []gin.H{},
	})
}

Go Fiber Handler (order_handler.go)

package handler

import (
	"github.com/gofiber/fiber/v2"
)

type OrderHandler struct{}

func NewOrderHandler() *OrderHandler {
	return &OrderHandler{}
}

func (h *OrderHandler) RegisterRoutes(router fiber.Router) {
	group := router.Group("/orders")
	group.Get("/", h.GetAll)
	group.Get("/:id", h.GetByID)
	group.Post("/", h.Create)
}

func (h *OrderHandler) GetAll(c *fiber.Ctx) error {
	return c.Status(fiber.StatusOK).JSON(fiber.Map{
		"success": true,
		"data":    []fiber.Map{},
	})
}

Python FastAPI Router (item_router.py)

from typing import List
from fastapi import APIRouter, HTTPException, status

router = APIRouter(prefix="/items", tags=["Items"])

@router.get("/", response_model=List[dict], status_code=status.HTTP_200_OK)
async def list_items():
    return []

@router.post("/", response_model=dict, status_code=status.HTTP_201_CREATED)
async def create_item(payload: dict):
    return {"id": "1", **payload}

Adding Custom Templates

You can add custom templates for any language or framework (TypeScript, React, Vue, Go, Python, Rust, NestJS, etc.).

1. Template Storage Directory

Templates are loaded globally from:

~/.codegen/templates/

(Tip: Open this folder quickly using the Command Palette: CodeGen: Open Global Templates Folder)

2. Directory Layout

Organize templates into subdirectories by language or category:

~/.codegen/templates/
├── laravel/
│   ├── controller/
│   │   ├── template.json
│   │   └── template.php
│   └── model/
│       ├── template.json
│       └── template.php
├── dart/
│   ├── dto/
│   │   ├── template.json
│   │   └── template.dart
│   └── bloc-freezed/
│       ├── template.json
│       ├── template.dart
│       └── state.dart
└── react/
    └── component/
        ├── template.json
        ├── template.tsx
        └── styles.module.css

3. template.json Configuration

Each template directory must contain a template.json file:

{
  "name": "Create React Component",
  "description": "Functional component with CSS module",
  "language": "typescript",
  "category": "react",
  "filename": "${NAME_PASCAL_CASE}.tsx",
  "variables": [
    {
      "name": "NAME",
      "prompt": "Component name (e.g. UserCard, Navbar)",
      "placeholder": "UserCard",
      "required": true,
      "pattern": "^[A-Za-z][A-Za-z0-9_]*$"
    }
  ],
  "children": [
    {
      "filename": "${NAME_PASCAL_CASE}.module.css",
      "template": "styles.module.css"
    }
  ]
}

4. Reload Templates

After adding or editing templates, reload them in VS Code without restarting:

CodeGen: Refresh Global Templates

Available Template Variables

CodeGen provides an extensive suite of built-in variables for code generation. Both ${VARIABLE} and $VARIABLE syntax are supported. In PHP code, local variables like $this, $request, and $id remain untouched.

1. Component & Case Transformations

These transformations apply to ${NAME} as well as any custom variable defined in template.json (such as ${FEATURE}, ${MODULE}, or ${ENTITY}):

2. Plural & Singular Transformations

CodeGen automatically handles English pluralization and singularization rules (e.g. category ↔ categories, box ↔ boxes, status ↔ statuses):

3. Date, Calendar & Time Variables

4. Unique Identifiers & Random Generators

5. System & Workspace Context

Extension Settings

Contributing

Issues, feedback, and pull requests for new built-in templates are welcome! Visit the repository on GitHub.

License

This project is open-sourced under the MIT License.