diff --git a/COMMANDS.md b/COMMANDS.md
new file mode 100644
index 0000000..827787a
--- /dev/null
+++ b/COMMANDS.md
@@ -0,0 +1,99 @@
+# devctl Commands Reference
+
+This document provides a comprehensive list of all commands available in the `devctl` CLI.
+
+## Overview
+
+`devctl` is organized into logical command groups. You can always run `devctl --help` or `devctl [command] --help` to get immediate assistance.
+
+---
+
+## 1. Project Initialization (`devctl init`)
+
+Initialize a new project with a standard boilerplate and optimized configuration.
+
+| Command | Usage | Description |
+| :--- | :--- | :--- |
+| **Spring Boot** | `devctl init spring [name]` | Downloads a Spring Boot project from start.spring.io. |
+| **Angular** | `devctl init angular [name]` | Scaffolds a new Angular project. |
+| **Vue.js** | `devctl init vue [name]` | Scaffolds a new Vue 3 project via Vite. |
+| **NestJS** | `devctl init nest [name]` | Scaffolds a new NestJS backend. |
+| **NodeJS** | `devctl init nodejs [name]` | Scaffolds a clean Express + TypeScript project. |
+| **ReactJS** | `devctl init react [name]` | Scaffolds a new React project via Vite. |
+| **NextJS** | `devctl init nextjs [name]` | Scaffolds a new NextJS project with App Router. |
+| **FastAPI** | `devctl init fastapi [name]` | Scaffolds a new FastAPI (Python) project. |
+| **Django** | `devctl init django [name]` | Scaffolds a new Django REST Framework project. |
+| **Svelte** | `devctl init svelte [name]` | Scaffolds a new SvelteKit project. |
+| **Go** | `devctl init go [name]` | Scaffolds a new Go (Fiber) project. |
+
+### Options
+*   `--db [postgres|mysql|mongodb]`: Specify the database driver for Spring Boot projects (Default: `postgres`).
+*   `--port [number]`: Specify a custom local port for the project.
+
+---
+
+## 2. Resource Scaffolding (`devctl add`)
+
+Inject business resources (Entities, Controllers, Services) into your existing project layers.
+
+| Command | Usage | Description |
+| :--- | :--- | :--- |
+| **Resource** | `devctl add resource [Name]` | Generates a full-stack feature for the given name. |
+
+### Parameters
+*   `--fields, -f`: Define fields in `name:type` format.
+    *   Example: `devctl add resource Product -f "name:string,price:double"`
+    *   Supported types: `string`, `int`, `double`, `float`, `boolean`, `date`.
+
+---
+
+## 3. Local Orchestration (`devctl run`)
+
+Launch your entire development environment in a single terminal.
+
+| Command | Usage | Description |
+| :--- | :--- | :--- |
+| **Run** | `devctl run` | Scans for databases, backends, and frontends and runs them. |
+
+### Execution Logic
+1.  **Databases**: Starts Docker Compose services first and waits for initialization.
+2.  **Backends**: Launches Spring, Nest, Express, Python, or Go APIs in parallel.
+3.  **Frontends**: Launches Angular, Vue, React, Svelte, or NextJS dev servers.
+4.  **Logging**: All output is prefixed by service name and color-coded.
+
+---
+
+## 4. Containerization (`devctl dockerize`)
+
+Generate optimized Dockerfiles for all detected projects.
+
+| Command | Usage | Description |
+| :--- | :--- | :--- |
+| **Dockerize** | `devctl dockerize [path]` | Scaffolds Multi-stage Dockerfiles for all services. |
+
+### Options
+*   `--force`: Overwrite existing Dockerfiles.
+*   `--dry-run`: Preview actions without writing files.
+
+---
+
+## 5. Deployment Preparation (`devctl deploy`)
+
+Prepare for multi-service production or staging deployments.
+
+| Command | Usage | Description |
+| :--- | :--- | :--- |
+| **Deploy** | `devctl deploy [path]` | Generates a global `docker-compose.yml` for all services. |
+
+### Features
+*   **Automatic Linking**: Detects database configurations from backends and automatically links them to database services in the global compose file.
+*   **Context Aware**: Uses relative paths for builds to ensure the compose file is portable.
+
+---
+
+## 6. Utilities
+
+| Command | Usage | Description |
+| :--- | :--- | :--- |
+| **Ping** | `devctl ping` | Returns "pong" to verify the CLI is operational. |
+| **Help** | `devctl --help` | Displays the global or command-specific help menu. |
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..80e4170
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,47 @@
+# Contributing to devctl
+
+Thank you for your interest in contributing to `devctl`! We welcome contributions from the community to make this tool even better.
+
+## How to Contribute
+
+1.  **Report Bugs**: If you find a bug, please open an issue on GitHub with a detailed description and steps to reproduce it.
+2.  **Suggest Features**: Have an idea for a new feature? Open an issue to discuss it.
+3.  **Submit Pull Requests**:
+    *   Fork the repository.
+    *   Create a new branch for your feature or bugfix.
+    *   Ensure your code follows the project's style (we use [Ruff](https://github.com/astral-sh/ruff)).
+    *   Add tests for any new functionality.
+    *   Submit a PR with a clear description of your changes.
+
+## Development Setup
+
+1.  Clone the repository:
+    ```bash
+    git clone https://github.com/your-username/devctl.git
+    cd devctl
+    ```
+2.  Create a virtual environment:
+    ```bash
+    python -m venv .venv
+    source .venv/bin/activate
+    ```
+3.  Install dependencies in editable mode:
+    ```bash
+    pip install -e .
+    ```
+4.  Run tests:
+    ```bash
+    pytest
+    ```
+
+## Code Quality
+
+We use `ruff` for linting and formatting. You can run it with:
+```bash
+ruff check .
+ruff format .
+```
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.
diff --git a/README.md b/README.md
index 8a6e5b5..61742f5 100644
--- a/README.md
+++ b/README.md
@@ -1,126 +1,86 @@
 # Devctl
 
-`devctl` is a command-line interface (CLI) that automates and orchestrates the
-local development lifecycle for Spring Boot, Angular, and Vue.js
-architectures.
+`devctl` is a professional command-line interface (CLI) designed to automate and
+orchestrate the development lifecycle for modern full-stack architectures. It
+provides a unified workflow for managing backends (Spring Boot, NestJS, Go,
+FastAPI), frontends (Angular, Vue, React, NextJS, Svelte), and their
+containerization.
+
+## Core Features
+
+-   **Multi-Stack Orchestration**: Launch databases, multiple microservices, and
+    frontend dev servers with a single command. Includes real-time, prefixed log
+    streaming.
+-   **Full-Stack Scaffolding**: Generate consistent business resources
+    (Entities, DTOs, Controllers, Services) across both backend and frontend
+    layers simultaneously.
+-   **Instant Infrastructure**: Automatically generate optimized, multi-stage
+    `Dockerfiles` and global `docker-compose.yml` configurations by scanning
+    your project tree.
+-   **Security by Default**: Inject standardized JWT authentication and security
+    configurations into new projects.
 
-## Purpose
-
-Full-stack development involves repetitive configuration and environment
-management tasks. `devctl` provides a unified control point to automate these
-processes, allowing you to focus on implementation rather than infrastructure.
-
-The tool addresses the following challenges:
-- Standardized database configuration using Docker.
-- Automated security boilerplate generation (JWT, filters, and configuration).
-- Surgical CRUD layer generation (entities, repositories, services, and
-  controllers).
-- Concurrent process management for multi-tier applications.
-- Automated environment cleanup.
+## Installation
 
-## Architecture and integration
+You can install `devctl` locally for development:
 
-The tool uses a modular Python 3 architecture and industry-standard libraries:
+```bash
+git clone https://github.com/yss-ef/devctl.git
+cd devctl
+pip install -e .
+```
 
-- CLI engine: Typer-based interface for type-safe command execution.
-- Templating: Jinja2 for dynamic generation of Java, TypeScript, and
-  configuration assets.
-- Spring integration: Connects with the Spring Initializr API for project
-  bootstrapping.
-- Frontend orchestration: Native support for @angular/cli and Vite.
-- Orchestration engine: Recursive scanning for project detection and parallel
-  process management.
-- Container management: Lifecycle management for Docker Compose, including
-  volume persistence control.
+## Quick Start
 
-## System requirements
+### 1. Initialize a Full-Stack Project
 
-The following dependencies must be in the system path:
+Create a new backend and frontend in seconds:
 
-- Python: version 3.9 or later.
-- Docker and Docker Compose.
-- Java: version 17 or later for Spring Boot modules.
-- Node.js and npm for Angular and Vue.js modules.
-- Angular CLI for Angular project initialization.
+```bash
+mkdir my-app && cd my-app
+devctl init spring api --db postgres
+devctl init angular front
+```
 
-## Installation
+### 2. Add a Business Resource
 
-1. Clone the repository:
-   ```bash
-   git clone https://github.com/your-username/devctl.git
-   cd devctl
-   ```
-2. Configure a virtual environment:
-   ```bash
-   python -m venv .venv
-   source .venv/bin/activate  # Linux/macOS
-   ```
-3. Install the package:
-   ```bash
-   pip install -e .
-   ```
-4. Verify the installation:
-   ```bash
-   devctl ping
-   ```
-
-## Command reference
-
-### Project initialization
-
-Bootstrap new projects with pre-configured defaults and security standards.
-
-- Spring Boot:
-  ```bash
-  devctl init spring "api-service" --db [postgres|mysql] --port 5432
-  ```
-- Angular:
-  ```bash
-  devctl init angular "web-client"
-  ```
-- Vue.js:
-  ```bash
-  devctl init vue "vue-client"
-  ```
-
-### Resource scaffolding
-
-Inject business resources into existing project structures. The command detects
-active modules and updates both backend and frontend layers.
+Generate a complete vertical slice of your application:
 
 ```bash
-devctl add resource "Product" --fields "name:string,price:double,quantity:int"
+devctl add resource Product -f "name:string,price:double,quantity:int"
 ```
 
-### Orchestration
+### 3. Run the Environment
 
-Scan the current directory tree and launch all detected components (database,
-backend, and frontend) in parallel.
+Launch everything in parallel with automatic database startup:
 
 ```bash
 devctl run
 ```
 
-Upon termination (Ctrl+C), `devctl` stops all processes and performs a clean
-teardown of Docker resources.
+## Supported Stacks
 
-### Dockerfile scaffolding
+| Type | Frameworks / Technologies |
+| :--- | :--- |
+| **Backends** | Spring Boot, NestJS, Express (NodeJS), FastAPI, Django, Go (Fiber) |
+| **Frontends** | Angular, Vue.js, ReactJS, NextJS, Svelte |
+| **Databases** | PostgreSQL, MySQL, MongoDB |
 
-Generate Dockerfiles for detected Spring Boot, Angular, and Vue/Vite services.
+## Documentation
 
-```bash
-devctl dockerize
-devctl dockerize ./my-workspace --dry-run
-devctl dockerize --force
-```
+For a detailed reference of all available commands and their options, see the
+[Commands Reference](COMMANDS.md).
+
+## Contributing
 
-Generated assets are limited to service-local `Dockerfile` files. Existing
-files are skipped unless you use the `--force` flag.
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for
+development setup and code quality guidelines.
 
 ## License
 
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 for details.
 
+---
 Authored by Youssef Fellah.
-Personal project.
+Professional Development Orchestrator.
diff --git a/devctl/commands/add.py b/devctl/commands/add.py
index d2c0d3f..dee58b0 100644
--- a/devctl/commands/add.py
+++ b/devctl/commands/add.py
@@ -1,6 +1,7 @@
 """
 CLI command group for adding new resources to existing projects.
-Supports Spring Boot, Angular, and Vue.js scaffolding.
+Supports Spring Boot, Angular, Vue.js, NestJS, NodeJS, React, NextJS, FastAPI,
+Django, Svelte, and Go scaffolding.
 """
 
 import os
@@ -8,7 +9,15 @@
 import typer
 
 from devctl.generators.scaffold_angular import generate_angular_resource
+from devctl.generators.scaffold_django import generate_django_resource
+from devctl.generators.scaffold_fastapi import generate_fastapi_resource
+from devctl.generators.scaffold_go import generate_go_resource
+from devctl.generators.scaffold_nestjs import generate_nest_resource
+from devctl.generators.scaffold_nextjs import generate_nextjs_resource
+from devctl.generators.scaffold_nodejs import generate_nodejs_resource
+from devctl.generators.scaffold_react import generate_react_resource
 from devctl.generators.scaffold_spring import generate_spring_resource
+from devctl.generators.scaffold_svelte import generate_svelte_resource
 from devctl.generators.scaffold_vue import generate_vue_resource
 from devctl.orchestrator.scanner import detect_environment
 from devctl.utils.dependencies import check_tool
@@ -26,7 +35,7 @@ def resource(
     """
     Scans the current folder and generates a suitable business architecture.
     """
-    typer.secho("🔍 Analyzing current context...", fg=typer.colors.CYAN)
+    typer.secho("Analyzing current context...", fg=typer.colors.CYAN)
     env_state = detect_environment(".")
 
     original_dir = os.getcwd()
@@ -37,13 +46,13 @@ def resource(
         check_tool("java", "generating Spring Boot resources")
         project_detected = True
         typer.secho(
-            "🍃 Spring Boot project detected. Launching Java generator...", fg=typer.colors.GREEN
+            "Spring Boot project detected. Launching Java generator...", fg=typer.colors.GREEN
         )
         os.chdir(env_state["spring_path"])
         try:
             generate_spring_resource(name, fields)
         except Exception as e:
-            typer.secho(f"❌ Error during Spring generation: {e}", fg=typer.colors.RED)
+            typer.secho(f"Error: Spring generation failed: {e}", fg=typer.colors.RED)
         finally:
             os.chdir(original_dir)
 
@@ -52,28 +61,106 @@ def resource(
         check_tool("npm", "generating Angular resources")
         project_detected = True
         typer.secho(
-            "🅰️ Angular project detected. Launching TypeScript generator...", fg=typer.colors.CYAN
+            "Angular project detected. Launching TypeScript generator...", fg=typer.colors.CYAN
         )
         try:
             generate_angular_resource(name, fields, root_path=".")
         except Exception as e:
-            typer.secho(f"❌ Error during Angular generation: {e}", fg=typer.colors.RED)
+            typer.secho(f"Error: Angular generation failed: {e}", fg=typer.colors.RED)
 
     # Check for Vue.js project
     if env_state.get("has_vue"):
         check_tool("npm", "generating Vue.js resources")
         project_detected = True
-        typer.secho("🟢 Vue.js project detected. Launching Vue generator...", fg=typer.colors.GREEN)
+        typer.secho("Vue.js project detected. Launching Vue generator...", fg=typer.colors.GREEN)
         try:
             generate_vue_resource(name, fields, root_path=".")
         except Exception as e:
-            typer.secho(f"❌ Error during Vue generation: {e}", fg=typer.colors.RED)
+            typer.secho(f"Error: Vue generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for NestJS project
+    if env_state.get("has_nest"):
+        project_detected = True
+        typer.secho("NestJS project detected. Launching Nest generator...", fg=typer.colors.CYAN)
+        try:
+            generate_nest_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Nest generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for React project
+    if env_state.get("has_react"):
+        project_detected = True
+        typer.secho("React project detected. Launching React generator...", fg=typer.colors.BLUE)
+        try:
+            generate_react_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: React generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for NextJS project
+    if env_state.get("has_nextjs"):
+        project_detected = True
+        typer.secho(
+            "NextJS project detected. Launching NextJS generator...", fg=typer.colors.YELLOW
+        )
+        try:
+            generate_nextjs_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: NextJS generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for FastAPI project
+    if env_state.get("has_fastapi"):
+        project_detected = True
+        typer.secho(
+            "FastAPI project detected. Launching FastAPI generator...", fg=typer.colors.CYAN
+        )
+        try:
+            generate_fastapi_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: FastAPI generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Django project
+    if env_state.get("has_django"):
+        project_detected = True
+        typer.secho("Django project detected. Launching Django generator...", fg=typer.colors.GREEN)
+        try:
+            generate_django_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Django generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Svelte project
+    if env_state.get("has_svelte"):
+        project_detected = True
+        typer.secho("Svelte project detected. Launching Svelte generator...", fg=typer.colors.RED)
+        try:
+            generate_svelte_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Svelte generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for Go project
+    if env_state.get("has_go"):
+        project_detected = True
+        typer.secho("Go project detected. Launching Go generator...", fg=typer.colors.CYAN)
+        try:
+            generate_go_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: Go generation failed: {e}", fg=typer.colors.RED)
+
+    # Check for NodeJS project
+    if os.path.exists("package.json") and not project_detected:
+        # Heuristic for generic nodejs project if not already caught by others
+        project_detected = True
+        typer.secho("NodeJS project detected. Launching NodeJS generator...", fg=typer.colors.GREEN)
+        try:
+            generate_nodejs_resource(name, fields, root_path=".")
+        except Exception as e:
+            typer.secho(f"Error: NodeJS generation failed: {e}", fg=typer.colors.RED)
 
     # Error message only if NO project detected
     if not project_detected:
         typer.secho(
-            "❌ Unable to determine project type. "
-            "Please run from within a Spring, Angular, or Vue.js project directory.",
+            "Error: Unable to determine project type. "
+            "Please run from within a supported project directory "
+            "(Spring, Angular, React, NextJS, FastAPI, Django, Svelte, Go, or Vue.js).",
             fg=typer.colors.RED,
         )
         raise typer.Exit(code=1)
diff --git a/devctl/commands/deploy.py b/devctl/commands/deploy.py
index 06ed213..cece1cb 100644
--- a/devctl/commands/deploy.py
+++ b/devctl/commands/deploy.py
@@ -3,6 +3,7 @@
 from typing import Any, Dict, Optional
 
 import typer
+import yaml
 from jinja2 import Environment, FileSystemLoader
 
 from devctl.generators.docker_scaffold import (
@@ -30,81 +31,156 @@ def extract_db_info(project_path: Path) -> Optional[Dict[str, Any]]:
 
     # spring.datasource.url=jdbc:postgresql://localhost:5432/sample_api_db
     url_match = re.search(r"spring\.datasource\.url=jdbc:([^:]+)://[^:]+:(\d+)/([\w-]+)", content)
+    # spring.data.mongodb.uri=mongodb://admin:password@localhost:27017/db_name
+    mongo_match = re.search(
+        r"spring\.data\.mongodb\.uri=mongodb://([^:]+):([^@]+)@[^:]+:(\d+)/([\w-]+)", content
+    )
+
     user_match = re.search(r"spring\.datasource\.username=([\w-]+)", content)
     pass_match = re.search(r"spring\.datasource\.password=([\w-]+)", content)
 
-    if not url_match:
+    if not url_match and not mongo_match:
         return extract_db_from_compose(project_path / "docker-compose.yml")
 
-    db_type_raw = url_match.group(1)
-    db_type = "postgresql" if "postgres" in db_type_raw else "mysql"
-    db_port = url_match.group(2)
-    db_name = url_match.group(3)
-    db_user = user_match.group(1) if user_match else "admin"
-    db_pass = pass_match.group(1) if pass_match else "password"
+    if mongo_match:
+        db_type = "mongodb"
+        db_user = mongo_match.group(1)
+        db_pass = mongo_match.group(2)
+        db_port = mongo_match.group(3)
+        db_name = mongo_match.group(4)
+    else:
+        db_type_raw = url_match.group(1)
+        db_type = "postgresql" if "postgres" in db_type_raw else "mysql"
+        db_port = url_match.group(2)
+        db_name = url_match.group(3)
+        db_user = user_match.group(1) if user_match else "admin"
+        db_pass = pass_match.group(1) if pass_match else "password"
 
     db_dict = _build_db_dict(db_type, db_port, db_name, db_user, db_pass)
-
+    ...
     # Try to refine service name from existing docker-compose if possible
     compose_path = project_path / "docker-compose.yml"
     if compose_path.exists():
-        compose_content = compose_path.read_text(encoding="utf-8", errors="ignore")
-        service_match = re.search(r"services:\s*\n\s+([\w-]+):", compose_content)
-        if service_match:
-            db_dict["service_name"] = service_match.group(1)
+        try:
+            with open(compose_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+                if config and "services" in config:
+                    # Find the first service that looks like a database
+                    for s_name, s_cfg in config["services"].items():
+                        image = str(s_cfg.get("image", ""))
+                        if db_type == "postgresql" and "postgres" in image:
+                            db_dict["service_name"] = s_name
+                            break
+                        if db_type == "mysql" and "mysql" in image:
+                            db_dict["service_name"] = s_name
+                            break
+                        if db_type == "mongodb" and "mongo" in image:
+                            db_dict["service_name"] = s_name
+                            break
+        except Exception:
+            pass
 
     return db_dict
 
 
 def extract_db_from_compose(compose_path: Path) -> Optional[Dict[str, Any]]:
     """
-    Extract database information from a docker-compose.yml file using regex.
+    Extract database information from a docker-compose.yml file using PyYAML.
     """
     if not compose_path.exists():
         return None
 
-    content = compose_path.read_text(encoding="utf-8", errors="ignore")
-
-    # This is a bit hacky without PyYAML but follows devctl's generated structure
-    # Try to find the first service name under 'services:'
-    service_match = re.search(r"services:\s*\n\s+([\w-]+):", content)
-    original_service_name = service_match.group(1) if service_match else None
-
-    image_match = re.search(r"image:\s+(postgres|mysql)(:[\w.-]+)?", content)
-    if not image_match:
+    try:
+        with open(compose_path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+    except Exception:
         return None
 
-    db_type = "postgresql" if image_match.group(1) == "postgres" else "mysql"
-
-    # Try to find env vars
-    if db_type == "postgresql":
-        user = re.search(r"POSTGRES_USER:\s+([\w-]+)", content)
-        password = re.search(r"POSTGRES_PASSWORD:\s+([\w-]+)", content)
-        db_name = re.search(r"POSTGRES_DB:\s+([\w-]+)", content)
-    else:
-        user = re.search(r"MYSQL_USER:\s+([\w-]+)", content)
-        password = re.search(r"MYSQL_PASSWORD:\s+([\w-]+)", content)
-        db_name = re.search(r"MYSQL_DATABASE:\s+([\w-]+)", content)
-
-    port_match = re.search(r"\"(\d+):(\d+)\"", content)
-
-    db_dict = _build_db_dict(
-        db_type,
-        port_match.group(1) if port_match else ("5432" if db_type == "postgresql" else "3306"),
-        db_name.group(1) if db_name else "db",
-        user.group(1) if user else "admin",
-        password.group(1) if password else "password",
-    )
+    if not config or "services" not in config:
+        return None
 
-    if original_service_name:
-        db_dict["service_name"] = original_service_name
+    for service_name, service_cfg in config["services"].items():
+        image = str(service_cfg.get("image", ""))
+        if "postgres" in image or "mysql" in image or "mongo" in image:
+            if "postgres" in image:
+                db_type = "postgresql"
+            elif "mysql" in image:
+                db_type = "mysql"
+            else:
+                db_type = "mongodb"
+
+            # Extract environment variables
+            env = service_cfg.get("environment", {})
+            env_dict = {}
+            if isinstance(env, list):
+                for item in env:
+                    if "=" in item:
+                        k, v = item.split("=", 1)
+                        env_dict[k] = v
+                    elif ":" in item:
+                        k, v = item.split(":", 1)
+                        env_dict[k] = v.strip()
+            elif isinstance(env, dict):
+                env_dict = env
+
+            # Extract info based on db_type
+            if db_type == "postgresql":
+                user = env_dict.get("POSTGRES_USER", "admin")
+                password = env_dict.get("POSTGRES_PASSWORD", "password")
+                db_name = env_dict.get("POSTGRES_DB", "db")
+            elif db_type == "mysql":
+                user = env_dict.get("MYSQL_USER", env_dict.get("MYSQL_ROOT_PASSWORD", "admin"))
+                password = env_dict.get(
+                    "MYSQL_PASSWORD", env_dict.get("MYSQL_ROOT_PASSWORD", "password")
+                )
+                db_name = env_dict.get("MYSQL_DATABASE", "db")
+            else:
+                user = env_dict.get("MONGO_INITDB_ROOT_USERNAME", "admin")
+                password = env_dict.get("MONGO_INITDB_ROOT_PASSWORD", "password")
+                db_name = env_dict.get("MONGO_INITDB_DATABASE", "db")
+
+            # Extract port
+            ports = service_cfg.get("ports", [])
+            host_port = None
+            if ports and isinstance(ports, list):
+                first_port = str(ports[0])
+                if ":" in first_port:
+                    host_port = first_port.split(":")[0].strip("'").strip('"')
+
+            db_dict = _build_db_dict(
+                db_type,
+                host_port
+                or (
+                    "5432"
+                    if db_type == "postgresql"
+                    else ("3306" if db_type == "mysql" else "27017")
+                ),
+                db_name,
+                user,
+                password,
+            )
+            db_dict["service_name"] = service_name
+            return db_dict
 
-    return db_dict
+    return None
 
 
 def _build_db_dict(db_type: str, port: str, name: str, user: str, password: str) -> Dict[str, Any]:
     is_postgres = db_type == "postgresql"
-    internal_port = "5432" if is_postgres else "3306"
+    is_mysql = db_type == "mysql"
+
+    if is_postgres:
+        internal_port = "5432"
+        image = "postgres:15-alpine"
+        vol_path = "/var/lib/postgresql/data"
+    elif is_mysql:
+        internal_port = "3306"
+        image = "mysql:8.0"
+        vol_path = "/var/lib/mysql/data"
+    else:
+        internal_port = "27017"
+        image = "mongo:6.0"
+        vol_path = "/data/db"
 
     env = {}
     if is_postgres:
@@ -113,13 +189,19 @@ def _build_db_dict(db_type: str, port: str, name: str, user: str, password: str)
             "POSTGRES_PASSWORD": password,
             "POSTGRES_DB": name,
         }
-    else:
+    elif is_mysql:
         env = {
             "MYSQL_ROOT_PASSWORD": password,
             "MYSQL_DATABASE": name,
             "MYSQL_USER": user,
             "MYSQL_PASSWORD": password,
         }
+    else:
+        env = {
+            "MONGO_INITDB_ROOT_USERNAME": user,
+            "MONGO_INITDB_ROOT_PASSWORD": password,
+            "MONGO_INITDB_DATABASE": name,
+        }
 
     return {
         "type": db_type,
@@ -129,9 +211,9 @@ def _build_db_dict(db_type: str, port: str, name: str, user: str, password: str)
         "user": user,
         "password": password,
         "service_name": f"{name}-db",
-        "image": "postgres:15-alpine" if is_postgres else "mysql:8.0",
+        "image": image,
         "volume_name": f"{name}_data",
-        "volume_path": "/var/lib/postgresql/data" if is_postgres else "/var/lib/mysql/data",
+        "volume_path": vol_path,
         "env": env,
     }
 
@@ -141,16 +223,18 @@ def deploy(path: Path = PATH_ARGUMENT):
     """
     Generate a global docker-compose.yml by scanning subdirectories.
     """
-    typer.secho(f"🚀 Preparing deployment for {path.resolve()}...", fg=typer.colors.CYAN, bold=True)
+    typer.secho(f"Preparing deployment for {path.resolve()}...", fg=typer.colors.CYAN, bold=True)
 
     try:
         projects = discover_docker_projects(path)
     except Exception as e:
-        typer.secho(f"❌ Error scanning projects: {e}", fg=typer.colors.RED)
+        typer.secho(f"Error: Scanning failed: {e}", fg=typer.colors.RED)
         raise typer.Exit(1) from e
 
     if not projects:
-        typer.secho("❌ No supported projects (Spring, Angular, Vue) found.", fg=typer.colors.RED)
+        typer.secho(
+            "Error: No supported projects (Spring, Angular, Vue) found.", fg=typer.colors.RED
+        )
         raise typer.Exit(1)
 
     services_data = []
@@ -161,7 +245,7 @@ def deploy(path: Path = PATH_ARGUMENT):
         dockerfile_path = project.path / "Dockerfile"
         if not dockerfile_path.exists():
             typer.secho(
-                f"⚠️ Warning: No Dockerfile found in {project.path}. "
+                f"Warning: No Dockerfile found in {project.path}. "
                 "You may need to run 'devctl dockerize' first.",
                 fg=typer.colors.YELLOW,
             )
@@ -199,5 +283,5 @@ def deploy(path: Path = PATH_ARGUMENT):
     output_path = path / "docker-compose.yml"
     output_path.write_text(output, encoding="utf-8")
 
-    typer.secho(f"✅ Generated {output_path}", fg=typer.colors.GREEN, bold=True)
+    typer.secho(f"Generated {output_path}", fg=typer.colors.GREEN, bold=True)
     typer.echo(f"Summary: {len(services_data)} services, {len(databases)} databases.")
diff --git a/devctl/commands/docker.py b/devctl/commands/docker.py
index 989916b..8faa8f5 100644
--- a/devctl/commands/docker.py
+++ b/devctl/commands/docker.py
@@ -43,11 +43,11 @@ def dockerize(
             dry_run=dry_run,
         )
     except DockerScaffoldError as exc:
-        typer.secho(f"❌ {exc}", fg=typer.colors.RED)
+        typer.secho(f"Error: {exc}", fg=typer.colors.RED)
         raise typer.Exit(code=1) from exc
 
     mode = "Dry run" if dry_run else "Docker scaffolding"
-    typer.secho(f"🐳 {mode} complete for {result.root_path}", fg=typer.colors.CYAN, bold=True)
+    typer.secho(f"{mode} complete for {result.root_path}", fg=typer.colors.CYAN, bold=True)
 
     typer.echo("\nDetected services:")
     for service in result.services:
diff --git a/devctl/commands/init.py b/devctl/commands/init.py
index bc819fe..2ccd6b4 100644
--- a/devctl/commands/init.py
+++ b/devctl/commands/init.py
@@ -1,15 +1,24 @@
 """
 CLI command group for initializing new projects.
-Supports Spring Boot, Angular, and Vue.js.
+Supports Spring Boot, Angular, Vue.js, NestJS, NodeJS, React, NextJS, FastAPI,
+Django, Svelte, and Go.
 """
 
 import typer
 
 # Angular generator
 from devctl.generators.angular import generate_angular_boilerplate
+from devctl.generators.django import generate_django_boilerplate
+from devctl.generators.fastapi import generate_fastapi_boilerplate
+from devctl.generators.go_fiber import generate_go_boilerplate
+from devctl.generators.nestjs import generate_nest_boilerplate
+from devctl.generators.nextjs import generate_nextjs_boilerplate
+from devctl.generators.nodejs import generate_nodejs_boilerplate
+from devctl.generators.react import generate_react_boilerplate
 
 # Spring generator
 from devctl.generators.spring import download_spring_boilerplate
+from devctl.generators.svelte import generate_svelte_boilerplate
 from devctl.generators.vue import generate_vue_boilerplate
 from devctl.orchestrator.config_builder import generate_config
 from devctl.utils.dependencies import check_tool
@@ -21,7 +30,7 @@
 @app.command("spring")
 def init_spring(
     name: str,
-    db: str = typer.Option("postgres", help="Database type (postgres or mysql)"),
+    db: str = typer.Option("postgres", help="Database type (postgres, mysql, or mongodb)"),
     port: int = typer.Option(None, help="Local port (optional)"),
 ):
     """
@@ -30,17 +39,17 @@ def init_spring(
     check_tool("java", "initializing a Spring Boot project")
 
     # Strict input validation
-    if db not in ["postgres", "mysql"]:
-        typer.secho(f"❌ Error: Database '{db}' is not supported.", fg=typer.colors.RED)
+    if db not in ["postgres", "mysql", "mongodb"]:
+        typer.secho(f"Error: Database '{db}' is not supported.", fg=typer.colors.RED)
         raise typer.Exit(code=1)
 
-    typer.secho(f"🚀 Initializing Spring Boot project: '{name}'...", fg=typer.colors.CYAN)
+    typer.secho(f"Initializing Spring Boot project: '{name}'...", fg=typer.colors.CYAN)
 
     success_download = download_spring_boilerplate(name, db_type=db)
 
     if success_download:
         generate_config(name, db_type=db, custom_port=port)
-        typer.secho("\n✨ Spring project ready!", fg=typer.colors.GREEN)
+        typer.secho("\nSpring project ready!", fg=typer.colors.GREEN)
 
 
 @app.command("angular")
@@ -51,11 +60,11 @@ def init_angular(name: str):
     check_tool("npm", "initializing an Angular project")
     check_tool("ng", "initializing an Angular project")
 
-    typer.secho(f"🚀 Initializing Angular project: '{name}'...", fg=typer.colors.CYAN)
+    typer.secho(f"Initializing Angular project: '{name}'...", fg=typer.colors.CYAN)
     success = generate_angular_boilerplate(name)
 
     if success:
-        typer.secho("\n✨ Angular project ready!", fg=typer.colors.GREEN)
+        typer.secho("\nAngular project ready!", fg=typer.colors.GREEN)
 
 
 @app.command("vue")
@@ -65,8 +74,120 @@ def init_vue(name: str):
     """
     check_tool("npm", "initializing a Vue.js project")
 
-    typer.secho(f"🚀 Initializing Vue.js project: '{name}'...", fg=typer.colors.CYAN)
+    typer.secho(f"Initializing Vue.js project: '{name}'...", fg=typer.colors.CYAN)
     success = generate_vue_boilerplate(name)
 
     if success:
-        typer.secho("\n✨ Vue.js project ready!", fg=typer.colors.GREEN)
+        typer.secho("\nVue.js project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("nest")
+def init_nest(name: str):
+    """
+    Initializes a new NestJS backend project.
+    """
+    check_tool("npm", "initializing a NestJS project")
+
+    typer.secho(f"Initializing NestJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_nest_boilerplate(name)
+
+    if success:
+        typer.secho("\nNestJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("nodejs")
+def init_nodejs(name: str):
+    """
+    Initializes a new NodeJS/Express backend project.
+    """
+    check_tool("npm", "initializing a NodeJS project")
+
+    typer.secho(f"Initializing NodeJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_nodejs_boilerplate(name)
+
+    if success:
+        typer.secho("\nNodeJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("react")
+def init_react(name: str):
+    """
+    Initializes a new ReactJS frontend project (Vite + TS).
+    """
+    check_tool("npm", "initializing a ReactJS project")
+
+    typer.secho(f"Initializing ReactJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_react_boilerplate(name)
+
+    if success:
+        typer.secho("\nReactJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("nextjs")
+def init_nextjs(name: str):
+    """
+    Initializes a new NextJS frontend project.
+    """
+    check_tool("npm", "initializing a NextJS project")
+
+    typer.secho(f"Initializing NextJS project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_nextjs_boilerplate(name)
+
+    if success:
+        typer.secho("\nNextJS project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("fastapi")
+def init_fastapi(name: str):
+    """
+    Initializes a new FastAPI backend project.
+    """
+    check_tool("python3", "initializing a FastAPI project")
+
+    typer.secho(f"Initializing FastAPI project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_fastapi_boilerplate(name)
+
+    if success:
+        typer.secho("\nFastAPI project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("django")
+def init_django(name: str):
+    """
+    Initializes a new Django backend project.
+    """
+    check_tool("python3", "initializing a Django project")
+
+    typer.secho(f"Initializing Django project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_django_boilerplate(name)
+
+    if success:
+        typer.secho("\nDjango project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("svelte")
+def init_svelte(name: str):
+    """
+    Initializes a new SvelteKit frontend project.
+    """
+    check_tool("npm", "initializing a Svelte project")
+
+    typer.secho(f"Initializing Svelte project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_svelte_boilerplate(name)
+
+    if success:
+        typer.secho("\nSvelte project ready!", fg=typer.colors.GREEN)
+
+
+@app.command("go")
+def init_go(name: str):
+    """
+    Initializes a new Go/Fiber backend project.
+    """
+    check_tool("go", "initializing a Go project")
+
+    typer.secho(f"Initializing Go project: '{name}'...", fg=typer.colors.CYAN)
+    success = generate_go_boilerplate(name)
+
+    if success:
+        typer.secho("\nGo project ready!", fg=typer.colors.GREEN)
diff --git a/devctl/commands/run.py b/devctl/commands/run.py
index e3d52f3..0ecb89b 100644
--- a/devctl/commands/run.py
+++ b/devctl/commands/run.py
@@ -3,10 +3,12 @@
 Automatically detects and launches backend, frontend, and database services.
 """
 
+from pathlib import Path
+
 import typer
 
+from devctl.generators.docker_scaffold import discover_docker_projects
 from devctl.orchestrator.runner import launch_dev_environment
-from devctl.orchestrator.scanner import detect_environment
 from devctl.utils.dependencies import check_tool
 
 app = typer.Typer(help="Local execution and development commands.")
@@ -15,42 +17,51 @@
 @app.callback(invoke_without_command=True)
 def run_env(ctx: typer.Context):
     """
-    Scans the current tree and automatically launches Spring, Angular, and the Database.
+    Scans the current tree and automatically launches Spring, Angular, Vue, and Databases.
     """
     if ctx.invoked_subcommand is not None:
         return
 
-    typer.secho("🔍 Analyzing the current directory tree...", fg=typer.colors.CYAN)
-    env_state = detect_environment(".")
+    typer.secho("Analyzing the current directory tree...", fg=typer.colors.CYAN)
+
+    projects = discover_docker_projects(".")
+
+    # Check for docker-compose.yml files
+    docker_composes = []
+    for p in Path(".").rglob("docker-compose.yml"):
+        if "node_modules" not in str(p) and "target" not in str(p) and ".git" not in str(p):
+            docker_composes.append(p.parent)
+
+    any(p.kind == "spring" for p in projects)
+    any(p.kind == "angular" for p in projects)
+    any(p.kind == "vue" for p in projects)
+    has_docker = len(docker_composes) > 0
 
     # Check dependencies based on detection
-    if env_state["has_docker_compose"]:
+    if has_docker:
         check_tool("docker", "running the database environment")
 
-    if env_state["has_spring"]:
-        check_tool("java", "running the Spring Boot backend")
-
-    if env_state["has_angular"] or env_state.get("has_vue"):
-        check_tool("npm", "running the frontend project")
+    # Group counts
+    counts = {}
+    for p in projects:
+        counts[p.kind] = counts.get(p.kind, 0) + 1
 
     # Visual summary of detection for the user
-    typer.echo(f"  - Docker Database  : {'✅' if env_state['has_docker_compose'] else '❌'}")
-    typer.echo(f"  - Spring Boot Backend : {'✅' if env_state['has_spring'] else '❌'}")
-    typer.echo(f"  - Angular Frontend    : {'✅' if env_state['has_angular'] else '❌'}")
-    typer.echo(f"  - Vue.js Frontend     : {'✅' if env_state['has_vue'] else '❌'}")
-
-    has_env = any(
-        [
-            env_state["has_docker_compose"],
-            env_state["has_spring"],
-            env_state["has_angular"],
-            env_state.get("has_vue"),
-        ]
-    )
-
-    if not has_env:
-        typer.secho("\n❌ No valid development environment detected here.", fg=typer.colors.RED)
+    def get_status(condition: bool):
+        return (
+            typer.style("FOUND", fg=typer.colors.GREEN)
+            if condition
+            else typer.style("MISSING", fg=typer.colors.RED)
+        )
+
+    typer.echo(f"  - Docker Compose ({len(docker_composes)}) : {get_status(has_docker)}")
+
+    for kind in sorted(counts.keys()):
+        typer.echo(f"  - {kind.capitalize()} ({counts[kind]}) : {get_status(True)}")
+
+    if not projects and not docker_composes:
+        typer.secho("\nError: No valid development environment detected here.", fg=typer.colors.RED)
         raise typer.Exit(code=1)
 
     # Transfer control to the system orchestration layer
-    launch_dev_environment(env_state)
+    launch_dev_environment(projects, docker_composes)
diff --git a/devctl/generators/angular.py b/devctl/generators/angular.py
index 9cf0a46..977f1be 100644
--- a/devctl/generators/angular.py
+++ b/devctl/generators/angular.py
@@ -15,7 +15,7 @@ def setup_angular_environments(project_path: str):
     """
     Generates environments and proxy for an Angular project.
     """
-    typer.secho("⚙️  Configuring Proxy and Environments...", fg=typer.colors.CYAN)
+    typer.secho("Configuring Proxy and Environments...", fg=typer.colors.CYAN)
 
     # 1. Target paths
     src_dir = os.path.join(project_path, "src")
@@ -39,7 +39,7 @@ def setup_angular_environments(project_path: str):
             with open(target_path, "w", encoding="utf-8") as f:
                 f.write(content)
         except Exception as e:
-            typer.secho(f"⚠️  Error generating {tpl_name}: {e}", fg=typer.colors.YELLOW)
+            typer.secho(f"Warning: Failed to generate {tpl_name}: {e}", fg=typer.colors.YELLOW)
 
     # 3. Modify angular.json to enable the proxy
     angular_json_path = os.path.join(project_path, "angular.json")
@@ -66,7 +66,7 @@ def setup_angular_environments(project_path: str):
             typer.echo("  - angular.json updated with proxyConfig.")
         except Exception as e:
             typer.secho(
-                f"⚠️  Unable to modify angular.json automatically: {e}",
+                f"Warning: Unable to modify angular.json automatically: {e}",
                 fg=typer.colors.YELLOW,
             )
 
@@ -75,7 +75,7 @@ def generate_angular_boilerplate(project_name: str) -> bool:
     """
     Generates an Angular project via the native CLI (@angular/cli) and configures it.
     """
-    typer.secho(f"🔄 Generating Angular frontend '{project_name}'...", fg=typer.colors.CYAN)
+    typer.secho(f"Generating Angular frontend '{project_name}'...", fg=typer.colors.CYAN)
 
     safe_name = project_name.lower().replace("_", "-")
 
@@ -83,20 +83,18 @@ def generate_angular_boilerplate(project_name: str) -> bool:
         subprocess.run(["ng", "version"], capture_output=True, check=True)
     except FileNotFoundError:
         typer.secho(
-            "❌ Error: Angular CLI ('ng') not found on your system.",
+            "Error: Angular CLI ('ng') not found on your system.",
             fg=typer.colors.RED,
         )
         return False
     except subprocess.CalledProcessError:
-        typer.secho("❌ Error: Angular CLI is installed but not responding.", fg=typer.colors.RED)
+        typer.secho("Error: Angular CLI is installed but not responding.", fg=typer.colors.RED)
         return False
 
     try:
         command = ["ng", "new", safe_name, "--routing=true", "--style=scss", "--skip-git=true"]
 
-        typer.secho(
-            "📦 Downloading npm packages... (This may take 1-2 minutes)", fg=typer.colors.CYAN
-        )
+        typer.secho("Downloading npm packages... (This may take 1-2 minutes)", fg=typer.colors.CYAN)
         subprocess.run(command, check=True)
 
         # Post-installation configuration
@@ -104,11 +102,11 @@ def generate_angular_boilerplate(project_name: str) -> bool:
         setup_angular_environments(project_full_path)
 
         typer.secho(
-            f"✅ Frontend '{safe_name}' successfully generated and configured!",
+            f"Frontend '{safe_name}' successfully generated and configured!",
             fg=typer.colors.GREEN,
         )
         return True
 
     except subprocess.CalledProcessError as e:
-        typer.secho(f"❌ Angular process failed with code: {e.returncode}", fg=typer.colors.RED)
+        typer.secho(f"Error: Angular process failed with code: {e.returncode}", fg=typer.colors.RED)
         return False
diff --git a/devctl/generators/django.py b/devctl/generators/django.py
new file mode 100644
index 0000000..c56a4ec
--- /dev/null
+++ b/devctl/generators/django.py
@@ -0,0 +1,61 @@
+"""
+Generators for Django projects.
+Includes boilerplate generation with Django and DRF.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_django_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new Django project.
+    """
+    typer.secho(f"Generating Django project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("-", "_")  # Django prefers underscores
+    project_path = os.path.join(os.getcwd(), project_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 1. Create requirements.txt
+        requirements = """django
+djangorestframework
+django-cors-headers
+"""
+        with open(os.path.join(project_path, "requirements.txt"), "w") as f:
+            f.write(requirements)
+
+        # 2. Create virtual environment
+        typer.secho("Creating virtual environment...", fg=typer.colors.CYAN)
+        subprocess.run(["python3", "-m", "venv", ".venv"], cwd=project_path, check=True)
+
+        # 3. Install Django
+        typer.secho("Installing Django and DRF...", fg=typer.colors.CYAN)
+        pip_path = os.path.join(".venv", "bin", "pip")
+        subprocess.run(
+            [pip_path, "install", "django", "djangorestframework"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        # 4. Start Project
+        typer.secho("Scaffolding Django project structure...", fg=typer.colors.CYAN)
+        django_admin = os.path.join(".venv", "bin", "django-admin")
+        subprocess.run([django_admin, "startproject", safe_name, "."], cwd=project_path, check=True)
+
+        # 5. Create core app
+        python_path = os.path.join(".venv", "bin", "python")
+        subprocess.run([python_path, "manage.py", "startapp", "core"], cwd=project_path, check=True)
+
+        typer.secho(
+            f"Django project '{project_name}' successfully generated!", fg=typer.colors.GREEN
+        )
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: Django initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/docker_scaffold.py b/devctl/generators/docker_scaffold.py
index 826ceca..040ca0f 100644
--- a/devctl/generators/docker_scaffold.py
+++ b/devctl/generators/docker_scaffold.py
@@ -16,6 +16,7 @@
     ".angular",
     ".git",
     ".mvn",
+    ".next",
     ".pytest_cache",
     ".venv",
     "__pycache__",
@@ -83,7 +84,7 @@ def sanitize_service_name(raw_name: str, fallback: str = "service") -> str:
 
 
 def discover_docker_projects(root_path: Union[str, Path]) -> list[DockerProject]:
-    """Discover all Spring Boot, Angular, and Vue/Vite projects under ``root_path``."""
+    """Discover all supported projects under ``root_path``."""
     root = Path(root_path).resolve()
     if not root.exists():
         raise DockerScaffoldError(f"Path does not exist: {root}")
@@ -102,9 +103,65 @@ def discover_docker_projects(root_path: Union[str, Path]) -> list[DockerProject]
             candidates.append(("spring", project_path))
         if "angular.json" in filename_set:
             candidates.append(("angular", project_path))
+
         has_vite_config = {"vite.config.ts", "vite.config.js"} & filename_set
         if has_vite_config and "angular.json" not in filename_set:
-            candidates.append(("vue", project_path))
+            # Check package.json to distinguish between vue and react
+            pkg_path = project_path / "package.json"
+            if pkg_path.exists():
+                try:
+                    pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+                    deps = pkg.get("dependencies", {})
+                    dev_deps = pkg.get("devDependencies", {})
+                    all_deps = {**deps, **dev_deps}
+
+                    if "vue" in all_deps:
+                        candidates.append(("vue", project_path))
+                    elif "react" in all_deps:
+                        candidates.append(("react", project_path))
+                    else:
+                        candidates.append(("vue", project_path))  # Fallback to vue
+                except Exception:
+                    candidates.append(("vue", project_path))
+            else:
+                candidates.append(("vue", project_path))
+
+        if "nest-cli.json" in filename_set:
+            candidates.append(("nest", project_path))
+
+        if any(f.startswith("next.config.") for f in filename_set):
+            candidates.append(("nextjs", project_path))
+
+        if "svelte.config.js" in filename_set:
+            candidates.append(("svelte", project_path))
+
+        if "main.py" in filename_set and "requirements.txt" in filename_set:
+            try:
+                reqs = (project_path / "requirements.txt").read_text()
+                if "fastapi" in reqs.lower():
+                    candidates.append(("fastapi", project_path))
+                elif "django" in reqs.lower():
+                    candidates.append(("django", project_path))
+            except Exception:
+                pass
+
+        if "manage.py" in filename_set and "requirements.txt" in filename_set:
+            try:
+                reqs = (project_path / "requirements.txt").read_text()
+                if "django" in reqs.lower():
+                    candidates.append(("django", project_path))
+            except Exception:
+                pass
+
+        if "go.mod" in filename_set:
+            candidates.append(("go", project_path))
+
+        if "package.json" in filename_set and not any(
+            k in ["angular", "vue", "react", "nest", "nextjs", "svelte"]
+            for k, p in candidates
+            if p == project_path
+        ):
+            candidates.append(("nodejs", project_path))
 
     used_names: set[str] = set()
     projects: list[DockerProject] = []
@@ -123,7 +180,9 @@ def discover_docker_projects(root_path: Union[str, Path]) -> list[DockerProject]
                 relative_context=_relative_context(root, project_path),
                 java_version=_spring_java_version(project_path) if kind == "spring" else None,
                 node_version=(
-                    _node_version(project_path, kind) if kind in {"angular", "vue"} else None
+                    _node_version(project_path, kind)
+                    if kind in {"angular", "vue", "react", "nest", "nodejs", "nextjs", "svelte"}
+                    else None
                 ),
                 angular_output_name=(
                     _angular_output_name(project_path) if kind == "angular" else None
@@ -144,7 +203,7 @@ def scaffold_docker_assets(
     root = Path(root_path).resolve()
     projects = discover_docker_projects(root)
     if not projects:
-        raise DockerScaffoldError("No Spring Boot, Angular, or Vue/Vite project detected.")
+        raise DockerScaffoldError("No supported project detected.")
 
     env = _template_environment()
     operations = [
@@ -163,6 +222,20 @@ def scaffold_docker_assets(
 def _dockerfile_content(env: Environment, project: DockerProject) -> str:
     if project.kind == "spring":
         return env.get_template("spring/Dockerfile.j2").render(project=project)
+    if project.kind == "nest":
+        return env.get_template("nestjs/Dockerfile.j2").render(project=project)
+    if project.kind == "nodejs":
+        return env.get_template("nodejs/Dockerfile.j2").render(project=project)
+    if project.kind == "nextjs":
+        return env.get_template("nextjs/Dockerfile.j2").render(project=project)
+    if project.kind == "fastapi":
+        return env.get_template("fastapi/Dockerfile.j2").render(project=project)
+    if project.kind == "django":
+        return env.get_template("django/Dockerfile.j2").render(project=project)
+    if project.kind == "svelte":
+        return env.get_template("svelte/Dockerfile.j2").render(project=project)
+    if project.kind == "go":
+        return env.get_template("go/Dockerfile.j2").render(project=project)
     return env.get_template("frontend/Dockerfile.j2").render(project=project)
 
 
@@ -294,6 +367,9 @@ def _node_version(project_path: Path, kind: str) -> str:
             return "20"
         return "18"
 
+    if kind in ["nest", "nodejs", "nextjs", "svelte"]:
+        return "20"
+
     return "22"
 
 
diff --git a/devctl/generators/fastapi.py b/devctl/generators/fastapi.py
new file mode 100644
index 0000000..1a3a11b
--- /dev/null
+++ b/devctl/generators/fastapi.py
@@ -0,0 +1,67 @@
+"""
+Generators for FastAPI projects.
+Includes boilerplate generation with Uvicorn and Pydantic.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_fastapi_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new FastAPI project.
+    """
+    typer.secho(f"Generating FastAPI project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+    project_path = os.path.join(os.getcwd(), safe_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 1. Create main.py
+        main_py = """from fastapi import FastAPI
+
+app = FastAPI(title="devctl FastAPI project")
+
+@app.get("/")
+def read_root():
+    return {"Hello": "from devctl FastAPI!"}
+
+@app.get("/items/{item_id}")
+def read_item(item_id: int, q: str = None):
+    return {"item_id": item_id, "q": q}
+"""
+        with open(os.path.join(project_path, "main.py"), "w") as f:
+            f.write(main_py)
+
+        # 2. Create requirements.txt
+        requirements = """fastapi
+uvicorn[standard]
+pydantic
+"""
+        with open(os.path.join(project_path, "requirements.txt"), "w") as f:
+            f.write(requirements)
+
+        # 3. Create virtual environment
+        typer.secho("Creating virtual environment...", fg=typer.colors.CYAN)
+        subprocess.run(["python3", "-m", "venv", ".venv"], cwd=project_path, check=True)
+
+        # 4. Install dependencies
+        typer.secho("Installing dependencies (fastapi, uvicorn)...", fg=typer.colors.CYAN)
+        # Note: on Linux it's .venv/bin/pip
+        pip_path = os.path.join(".venv", "bin", "pip")
+        subprocess.run(
+            [pip_path, "install", "-r", "requirements.txt"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        typer.secho(f"FastAPI project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: FastAPI initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/go_fiber.py b/devctl/generators/go_fiber.py
new file mode 100644
index 0000000..628e655
--- /dev/null
+++ b/devctl/generators/go_fiber.py
@@ -0,0 +1,61 @@
+"""
+Generators for Go (Fiber) projects.
+Includes boilerplate generation with Fiber framework.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_go_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new Go + Fiber project.
+    """
+    typer.secho(f"Generating Go project '{project_name}'...", fg=typer.colors.CYAN)
+    project_path = os.path.join(os.getcwd(), project_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 1. Go mod init
+        typer.secho("Initializing Go module...", fg=typer.colors.CYAN)
+        subprocess.run(["go", "mod", "init", project_name], cwd=project_path, check=True)
+
+        # 2. Install Fiber
+        typer.secho("Installing Fiber framework...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["go", "get", "github.com/gofiber/fiber/v2"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        # 3. Create main.go
+        main_go = """package main
+
+import (
+    "log"
+    "github.com/gofiber/fiber/v2"
+)
+
+func main() {
+    app := fiber.New()
+
+    app.Get("/", func(c *fiber.Ctx) error {
+        return c.SendString("Hello from devctl Go/Fiber!")
+    })
+
+    log.Fatal(app.Listen(":3000"))
+}
+"""
+        with open(os.path.join(project_path, "main.go"), "w") as f:
+            f.write(main_go)
+
+        typer.secho(f"Go project '{project_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: Go initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/nestjs.py b/devctl/generators/nestjs.py
new file mode 100644
index 0000000..c1ad0d7
--- /dev/null
+++ b/devctl/generators/nestjs.py
@@ -0,0 +1,49 @@
+"""
+Generators for NestJS projects.
+Includes boilerplate generation via Nest CLI.
+"""
+
+import subprocess
+
+import typer
+
+
+def generate_nest_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new NestJS project using the Nest CLI via npx.
+    """
+    typer.secho(f"Generating NestJS project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        # Use npx to run Nest CLI without requiring global installation
+        # --package-manager npm: ensures npm is used
+        # --strict: enables strict mode
+        # --skip-git: devctl might be in a git repo already
+        typer.secho("Scaffolding NestJS project (this may take a minute)...", fg=typer.colors.CYAN)
+        subprocess.run(
+            [
+                "npx",
+                "-p",
+                "@nestjs/cli",
+                "nest",
+                "new",
+                safe_name,
+                "--package-manager",
+                "npm",
+                "--skip-git",
+            ],
+            check=True,
+        )
+
+        typer.secho(f"NestJS project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"Error: Nest CLI process failed with code: {e.returncode}", fg=typer.colors.RED
+        )
+        return False
+    except FileNotFoundError:
+        typer.secho("Error: 'npx' or 'npm' not found in path.", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/nextjs.py b/devctl/generators/nextjs.py
new file mode 100644
index 0000000..892d205
--- /dev/null
+++ b/devctl/generators/nextjs.py
@@ -0,0 +1,51 @@
+"""
+Generators for NextJS projects.
+Includes boilerplate generation via create-next-app.
+"""
+
+import subprocess
+
+import typer
+
+
+def generate_nextjs_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new NextJS project using create-next-app via npx.
+    """
+    typer.secho(f"Generating NextJS project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding NextJS project (this may take a minute)...", fg=typer.colors.CYAN)
+        # --ts: TypeScript
+        # --eslint: ESLint
+        # --tailwind: Tailwind CSS
+        # --src-dir: Use src/ directory
+        # --app: Use App Router
+        # --import-alias: alias for imports
+        subprocess.run(
+            [
+                "npx",
+                "create-next-app@latest",
+                safe_name,
+                "--ts",
+                "--eslint",
+                "--tailwind",
+                "--src-dir",
+                "--app",
+                "--import-alias",
+                "@/*",
+                "--use-npm",
+            ],
+            check=True,
+        )
+
+        typer.secho(f"NextJS project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"Error: NextJS creation failed with code: {e.returncode}", fg=typer.colors.RED)
+        return False
+    except Exception as e:
+        typer.secho(f"Error: NextJS initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/nodejs.py b/devctl/generators/nodejs.py
new file mode 100644
index 0000000..f601714
--- /dev/null
+++ b/devctl/generators/nodejs.py
@@ -0,0 +1,110 @@
+"""
+Generators for NodeJS (Express) projects.
+Includes boilerplate generation with TypeScript and Express.
+"""
+
+import json
+import os
+import subprocess
+
+import typer
+
+
+def generate_nodejs_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new NodeJS + Express + TypeScript project.
+    """
+    typer.secho(f"Generating NodeJS/Express project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+    project_path = os.path.join(os.getcwd(), safe_name)
+
+    try:
+        os.makedirs(project_path, exist_ok=True)
+
+        # 1. Initialize package.json
+        typer.secho("Initializing package.json...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["npm", "init", "-y"], cwd=project_path, check=True, stdout=subprocess.DEVNULL
+        )
+
+        # 2. Install dependencies
+        typer.secho(
+            "Installing dependencies (express, typescript, ts-node, nodemon)...",
+            fg=typer.colors.CYAN,
+        )
+        subprocess.run(
+            ["npm", "install", "express", "dotenv"],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+        subprocess.run(
+            [
+                "npm",
+                "install",
+                "-D",
+                "typescript",
+                "@types/node",
+                "@types/express",
+                "ts-node",
+                "nodemon",
+                "rimraf",
+            ],
+            cwd=project_path,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+
+        # 3. Initialize TypeScript
+        typer.secho("Configuring TypeScript...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["npx", "tsc", "--init"], cwd=project_path, check=True, stdout=subprocess.DEVNULL
+        )
+
+        # 4. Create folder structure
+        os.makedirs(os.path.join(project_path, "src"), exist_ok=True)
+
+        # 5. Create basic index.ts
+        index_ts = """import express, { Request, Response } from 'express';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.use(express.json());
+
+app.get('/', (req: Request, res: Response) => {
+  res.send('Hello from devctl NodeJS/Express!');
+});
+
+app.listen(port, () => {
+  console.log(`[server]: Server is running at http://localhost:${port}`);
+});
+"""
+        with open(os.path.join(project_path, "src", "index.ts"), "w") as f:
+            f.write(index_ts)
+
+        # 6. Update package.json scripts
+        with open(os.path.join(project_path, "package.json"), "r") as f:
+            pkg = json.load(f)
+
+        pkg["scripts"] = {
+            "start": "node dist/index.js",
+            "build": "rimraf dist && tsc",
+            "dev": "nodemon src/index.ts",
+        }
+
+        with open(os.path.join(project_path, "package.json"), "w") as f:
+            json.dump(pkg, f, indent=2)
+
+        typer.secho(
+            f"NodeJS/Express project '{safe_name}' successfully generated!",
+            fg=typer.colors.GREEN,
+        )
+        return True
+
+    except Exception as e:
+        typer.secho(f"Error: NodeJS/Express initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/react.py b/devctl/generators/react.py
new file mode 100644
index 0000000..5256afb
--- /dev/null
+++ b/devctl/generators/react.py
@@ -0,0 +1,43 @@
+"""
+Generators for ReactJS projects via Vite.
+Includes boilerplate generation and basic configuration.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_react_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new React + TypeScript project via Vite.
+    """
+    typer.secho(f"Generating ReactJS frontend '{project_name}' via Vite...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding React project...", fg=typer.colors.CYAN)
+        subprocess.run(
+            ["npm", "create", "vite@latest", safe_name, "--", "--template", "react-ts"],
+            check=True,
+        )
+
+        project_full_path = os.path.join(os.getcwd(), safe_name)
+
+        typer.secho("Installing npm dependencies...", fg=typer.colors.CYAN)
+        subprocess.run(["npm", "install"], cwd=project_full_path, check=True)
+
+        typer.secho(
+            f"ReactJS frontend '{safe_name}' successfully generated!", fg=typer.colors.GREEN
+        )
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"Error: React/Vite process failed with code: {e.returncode}", fg=typer.colors.RED
+        )
+        return False
+    except Exception as e:
+        typer.secho(f"Error: React/Vite initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/scaffold_angular.py b/devctl/generators/scaffold_angular.py
index 06f4255..52e3793 100644
--- a/devctl/generators/scaffold_angular.py
+++ b/devctl/generators/scaffold_angular.py
@@ -43,7 +43,7 @@ def generate_angular_resource(resource_name: str, fields_str: str, root_path: st
     env_state = detect_environment(root_path)
 
     if not env_state["has_angular"]:
-        typer.secho("❌ Error: No Angular project detected here.", fg=typer.colors.RED)
+        typer.secho("Error: No Angular project detected here.", fg=typer.colors.RED)
         raise typer.Exit(code=1)
 
     angular_root = env_state["angular_path"]
@@ -120,7 +120,7 @@ def generate_angular_resource(resource_name: str, fields_str: str, root_path: st
     templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "angular", "feature")
     env = Environment(loader=FileSystemLoader(templates_dir))
 
-    typer.secho(f"⚙️  Generating Angular feature '{entity_name}'...", fg=typer.colors.CYAN)
+    typer.secho(f"Generating Angular feature '{entity_name}'...", fg=typer.colors.CYAN)
 
     # Template data
     context = {
@@ -155,6 +155,9 @@ def generate_angular_resource(resource_name: str, fields_str: str, root_path: st
                     f.write("")
                 typer.echo(f"  - Created (empty): {comp['dir']}/{target_file_name}")
             else:
-                typer.secho(f"⚠️  Error on {comp['template']}: {e}", fg=typer.colors.YELLOW)
+                typer.secho(
+                    f"Warning: Failed to generate {comp['template']}: {e}",
+                    fg=typer.colors.YELLOW,
+                )
 
-    typer.secho(f"✅ {entity_name} feature successfully generated!", fg=typer.colors.GREEN)
+    typer.secho(f"{entity_name} feature successfully generated!", fg=typer.colors.GREEN)
diff --git a/devctl/generators/scaffold_django.py b/devctl/generators/scaffold_django.py
new file mode 100644
index 0000000..174af2f
--- /dev/null
+++ b/devctl/generators/scaffold_django.py
@@ -0,0 +1,79 @@
+"""
+Django resource scaffolding generator.
+Handles the creation of models, serializers, and views.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_django_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a Django resource.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_django"]:
+        typer.secho("❌ Error: No Django project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    django_root = env_state["django_path"]
+    resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: core/models.py, core/serializers.py, core/views.py
+    # For simplicity, we inject into the 'core' app created during init
+    core_dir = os.path.join(django_root, "core")
+    if not os.path.exists(core_dir):
+        os.makedirs(core_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating Django resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Append Model
+    model_snippet = f"""
+class {entity_name}(models.Model):
+    # Fields: {fields_str}
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f"{entity_name} {{self.id}}"
+"""
+    with open(os.path.join(core_dir, "models.py"), "a") as f:
+        f.write(model_snippet)
+
+    # 2. Append Serializer
+    serializer_path = os.path.join(core_dir, "serializers.py")
+    if not os.path.exists(serializer_path):
+        with open(serializer_path, "w") as f:
+            f.write("from rest_framework import serializers\nfrom .models import *\n")
+
+    serializer_snippet = f"""
+class {entity_name}Serializer(serializers.ModelSerializer):
+    class Meta:
+        model = {entity_name}
+        fields = '__all__'
+"""
+    with open(serializer_path, "a") as f:
+        f.write(serializer_snippet)
+
+    # 3. Append View
+    view_snippet = f"""
+from rest_framework import viewsets
+from .models import {entity_name}
+from .serializers import {entity_name}Serializer
+
+class {entity_name}ViewSet(viewsets.ModelViewSet):
+    queryset = {entity_name}.objects.all()
+    serializer_class = {entity_name}Serializer
+"""
+    with open(os.path.join(core_dir, "views.py"), "a") as f:
+        f.write(view_snippet)
+
+    typer.secho(f"✅ {entity_name} Django feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo("  - Updated: core/models.py")
+    typer.echo("  - Updated: core/serializers.py")
+    typer.echo("  - Updated: core/views.py")
diff --git a/devctl/generators/scaffold_fastapi.py b/devctl/generators/scaffold_fastapi.py
new file mode 100644
index 0000000..d6d71da
--- /dev/null
+++ b/devctl/generators/scaffold_fastapi.py
@@ -0,0 +1,101 @@
+"""
+FastAPI resource scaffolding generator.
+Handles the creation of routers, schemas, and models.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_fastapi_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a FastAPI resource.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_fastapi"]:
+        typer.secho("❌ Error: No FastAPI project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    fastapi_root = env_state["fastapi_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Create directories
+    routers_dir = os.path.join(fastapi_root, "routers")
+    schemas_dir = os.path.join(fastapi_root, "schemas")
+    models_dir = os.path.join(fastapi_root, "models")
+
+    for d in [routers_dir, schemas_dir, models_dir]:
+        os.makedirs(d, exist_ok=True)
+        # Ensure __init__.py exists
+        with open(os.path.join(d, "__init__.py"), "a"):
+            pass
+
+    typer.secho(f"Generating FastAPI resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Schema (Pydantic)
+    schema_content = f"""from pydantic import BaseModel
+from typing import Optional
+
+class {entity_name}Base(BaseModel):
+    # Fields: {fields_str}
+    pass
+
+class {entity_name}Create({entity_name}Base):
+    pass
+
+class {entity_name}({entity_name}Base):
+    id: int
+
+    class Config:
+        orm_mode = True
+"""
+    with open(os.path.join(schemas_dir, f"{resource_lower}.py"), "w") as f:
+        f.write(schema_content)
+
+    # 2. Generate Router
+    router_content = f"""from fastapi import APIRouter, HTTPException
+from typing import List
+from schemas import {resource_lower} as schemas
+
+router = APIRouter(
+    prefix="/{resource_lower}s",
+    tags=["{resource_lower}s"]
+)
+
+@{resource_lower}.get("/", response_model=List[schemas.{entity_name}])
+def read_{resource_lower}s():
+    return []
+
+@{resource_lower}.post("/", response_model=schemas.{entity_name})
+def create_{resource_lower}({resource_lower}: schemas.{entity_name}Create):
+    return {{"id": 1, **{resource_lower}.dict()}}
+"""
+    # Note: fixed typo in template during thought but let's correct it properly
+    router_content = f"""from fastapi import APIRouter, HTTPException
+from typing import List
+from schemas import {resource_lower} as schemas
+
+router = APIRouter(
+    prefix="/{resource_lower}s",
+    tags=["{resource_lower}s"]
+)
+
+@router.get("/", response_model=List[schemas.{entity_name}])
+def read_{resource_lower}s():
+    return []
+
+@router.post("/", response_model=schemas.{entity_name})
+def create_{resource_lower}(item: schemas.{entity_name}Create):
+    return {{"id": 1, **item.dict()}}
+"""
+    with open(os.path.join(routers_dir, f"{resource_lower}.py"), "w") as f:
+        f.write(router_content)
+
+    typer.secho(f"✅ {entity_name} FastAPI feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: schemas/{resource_lower}.py")
+    typer.echo(f"  - Created: routers/{resource_lower}.py")
diff --git a/devctl/generators/scaffold_go.py b/devctl/generators/scaffold_go.py
new file mode 100644
index 0000000..0f0499e
--- /dev/null
+++ b/devctl/generators/scaffold_go.py
@@ -0,0 +1,67 @@
+"""
+Go (Fiber) resource scaffolding generator.
+Handles the creation of handlers and models.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_go_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a Go resource.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_go"]:
+        typer.secho("❌ Error: No Go project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    go_root = env_state["go_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: handlers/resource.go, models/resource.go
+    handlers_dir = os.path.join(go_root, "handlers")
+    models_dir = os.path.join(go_root, "models")
+
+    os.makedirs(handlers_dir, exist_ok=True)
+    os.makedirs(models_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating Go resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Model
+    model_content = f"""package models
+
+type {entity_name} struct {{
+    ID uint `json:"id"`
+    // Fields: {fields_str}
+}}
+"""
+    with open(os.path.join(models_dir, f"{resource_lower}.go"), "w") as f:
+        f.write(model_content)
+
+    # 2. Generate Handler
+    handler_content = f"""package handlers
+
+import (
+    "github.com/gofiber/fiber/v2"
+)
+
+func Get{entity_name}s(c *fiber.Ctx) error {{
+    return c.JSON(fiber.Map{{"message": "Get all {resource_lower}s"}})
+}}
+
+func Create{entity_name}(c *fiber.Ctx) error {{
+    return c.Status(201).JSON(fiber.Map{{"message": "{entity_name} created"}})
+}}
+"""
+    with open(os.path.join(handlers_dir, f"{resource_lower}.go"), "w") as f:
+        f.write(handler_content)
+
+    typer.secho(f"✅ {entity_name} Go feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: models/{resource_lower}.go")
+    typer.echo(f"  - Created: handlers/{resource_lower}.go")
diff --git a/devctl/generators/scaffold_nestjs.py b/devctl/generators/scaffold_nestjs.py
new file mode 100644
index 0000000..35d5f5e
--- /dev/null
+++ b/devctl/generators/scaffold_nestjs.py
@@ -0,0 +1,51 @@
+"""
+NestJS resource scaffolding generator.
+Handles the creation of modules, controllers, and services using Nest CLI.
+"""
+
+import subprocess
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_nest_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a NestJS resource using the Nest CLI.
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_nest"]:
+        typer.secho("❌ Error: No NestJS project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    nest_root = env_state["nest_path"]
+    resource_lower = resource_name.lower()
+
+    typer.secho(f"⚙️  Generating NestJS resource '{resource_name}'...", fg=typer.colors.CYAN)
+
+    try:
+        # Use npx to run Nest CLI
+        # 'g res' is shorthand for 'generate resource'
+        # --no-spec skips test files for a cleaner scaffold
+        subprocess.run(
+            ["npx", "@nestjs/cli", "g", "resource", resource_lower, "--no-spec"],
+            cwd=nest_root,
+            check=True,
+        )
+
+        typer.secho(
+            f"{resource_name} NestJS resource successfully generated!", fg=typer.colors.GREEN
+        )
+        typer.echo(
+            f"Hint: Fields [{fields_str}] were provided but manual DTO update is recommended."
+        )
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"Error: Nest CLI resource generation failed with code: {e.returncode}",
+            fg=typer.colors.RED,
+        )
+    except Exception as e:
+        typer.secho(f"Warning: An unexpected error occurred: {e}", fg=typer.colors.YELLOW)
diff --git a/devctl/generators/scaffold_nextjs.py b/devctl/generators/scaffold_nextjs.py
new file mode 100644
index 0000000..5014a12
--- /dev/null
+++ b/devctl/generators/scaffold_nextjs.py
@@ -0,0 +1,73 @@
+"""
+NextJS resource scaffolding generator.
+Handles the creation of pages and components in the App Router.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_nextjs_resource(resource_name: str, _fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a NextJS resource (Page, Component).
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_nextjs"]:
+        typer.secho("❌ Error: No NextJS project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    nextjs_root = env_state["nextjs_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: src/app/resource-name/page.tsx
+    app_dir = os.path.join(nextjs_root, "src", "app", resource_lower)
+    components_dir = os.path.join(nextjs_root, "src", "components")
+
+    os.makedirs(app_dir, exist_ok=True)
+    os.makedirs(components_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating NextJS resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Page (tsx)
+    page_content = f"""import React from 'react';
+import {{ {entity_name}List }} from '@/components/{entity_name}List';
+
+export default function {entity_name}Page() {{
+  return (
+    <main className="p-8">
+      <h1 className="text-2xl font-bold mb-4">{entity_name} Management</h1>
+      <{entity_name}List />
+    </main>
+  );
+}}
+"""
+    with open(os.path.join(app_dir, "page.tsx"), "w") as f:
+        f.write(page_content)
+
+    # 2. Generate Component
+    component_content = f"""import React from 'react';
+
+export const {entity_name}List: React.FC = () => {{
+  return (
+    <div className="border p-4 rounded shadow">
+      <h2 className="text-xl font-semibold mb-2">{entity_name} List</h2>
+      <p>This component was generated by devctl.</p>
+      <ul className="list-disc pl-5 mt-4">
+        <li>Item 1</li>
+        <li>Item 2</li>
+      </ul>
+    </div>
+  );
+}};
+"""
+    with open(os.path.join(components_dir, f"{entity_name}List.tsx"), "w") as f:
+        f.write(component_content)
+
+    typer.secho(f"✅ {entity_name} NextJS feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: src/app/{resource_lower}/page.tsx")
+    typer.echo(f"  - Created: src/components/{entity_name}List.tsx")
diff --git a/devctl/generators/scaffold_nodejs.py b/devctl/generators/scaffold_nodejs.py
new file mode 100644
index 0000000..0e4b776
--- /dev/null
+++ b/devctl/generators/scaffold_nodejs.py
@@ -0,0 +1,81 @@
+"""
+NodeJS/Express resource scaffolding generator.
+Handles the creation of routes and controllers.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_nodejs_resource(resource_name: str, _fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a NodeJS/Express resource.
+    """
+    # Using basic manual file writing for simplicity and speed
+    # In a more advanced version, we could use Jinja2 templates
+
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    src_dir = os.path.join(root_path, "src")
+    if not os.path.exists(src_dir):
+        # Try to find nodejs path from scanner
+        detect_environment(root_path)
+        # We need to add has_nodejs to scanner or just check if src exists in root
+        src_dir = os.path.join(root_path, "src")
+
+    routes_dir = os.path.join(src_dir, "routes")
+    controllers_dir = os.path.join(src_dir, "controllers")
+
+    os.makedirs(routes_dir, exist_ok=True)
+    os.makedirs(controllers_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating NodeJS/Express resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Controller
+    controller_content = f"""import {{ Request, Response }} from 'express';
+
+export const get{entity_name}s = (req: Request, res: Response) => {{
+  res.json({{ message: 'Get all {resource_lower}s' }});
+}};
+
+export const get{entity_name}ById = (req: Request, res: Response) => {{
+  const {{ id }} = req.params;
+  res.json({{ message: `Get {resource_lower} with id ${{id}}` }});
+}};
+
+export const create{entity_name} = (req: Request, res: Response) => {{
+  const data = req.body;
+  res.status(201).json({{
+    message: '{entity_name} created',
+    data
+  }});
+}};
+"""
+    controller_path = os.path.join(controllers_dir, f"{resource_lower}.controller.ts")
+    with open(controller_path, "w") as f:
+        f.write(controller_content)
+
+    # 2. Generate Route
+    route_content = f"""import {{ Router }} from 'express';
+import * as {resource_lower}Controller from '../controllers/{resource_lower}.controller';
+
+const router = Router();
+
+router.get('/', {resource_lower}Controller.get{entity_name}s);
+router.get('/:id', {resource_lower}Controller.get{entity_name}ById);
+router.post('/', {resource_lower}Controller.create{entity_name});
+
+export default router;
+"""
+    route_path = os.path.join(routes_dir, f"{resource_lower}.routes.ts")
+    with open(route_path, "w") as f:
+        f.write(route_content)
+
+    typer.secho(f"✅ {entity_name} NodeJS resource successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: controllers/{resource_lower}.controller.ts")
+    typer.echo(f"  - Created: routes/{resource_lower}.routes.ts")
+    typer.echo("💡 Don't forget to register the route in your main app file.")
diff --git a/devctl/generators/scaffold_react.py b/devctl/generators/scaffold_react.py
new file mode 100644
index 0000000..e6f751a
--- /dev/null
+++ b/devctl/generators/scaffold_react.py
@@ -0,0 +1,80 @@
+"""
+ReactJS resource scaffolding generator.
+Handles the creation of components, hooks, and services.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_react_resource(resource_name: str, fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a React resource (Component, Service).
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_react"]:
+        typer.secho("❌ Error: No ReactJS project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    react_root = env_state["react_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: src/components/ResourceName/...
+    components_dir = os.path.join(react_root, "src", "components", entity_name)
+    services_dir = os.path.join(react_root, "src", "services")
+
+    os.makedirs(components_dir, exist_ok=True)
+    os.makedirs(services_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating ReactJS resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate Component (tsx)
+    component_content = f"""import React from 'react';
+
+export const {entity_name}List: React.FC = () => {{
+  return (
+    <div>
+      <h1>{entity_name} List</h1>
+      <p>Manage your {resource_lower}s here.</p>
+    </div>
+  );
+}};
+
+export const {entity_name}Form: React.FC = () => {{
+  return (
+    <form>
+      <h1>Create {entity_name}</h1>
+      {fields_str}
+    </form>
+  );
+}};
+"""
+    with open(os.path.join(components_dir, f"{entity_name}.tsx"), "w") as f:
+        f.write(component_content)
+
+    # 2. Generate Service
+    service_content = f"""export const fetch{entity_name}s = async () => {{
+  const response = await fetch('/api/{resource_lower}s');
+  return response.json();
+}};
+
+export const create{entity_name} = async (data: any) => {{
+  const response = await fetch('/api/{resource_lower}s', {{
+    method: 'POST',
+    body: JSON.stringify(data),
+    headers: {{ 'Content-Type': 'application/json' }}
+  }});
+  return response.json();
+}};
+"""
+    with open(os.path.join(services_dir, f"{resource_lower}.service.ts"), "w") as f:
+        f.write(service_content)
+
+    typer.secho(f"✅ {entity_name} React feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: src/components/{entity_name}/{entity_name}.tsx")
+    typer.echo(f"  - Created: src/services/{resource_lower}.service.ts")
diff --git a/devctl/generators/scaffold_spring.py b/devctl/generators/scaffold_spring.py
index 92fb5ed..39ce0b3 100644
--- a/devctl/generators/scaffold_spring.py
+++ b/devctl/generators/scaffold_spring.py
@@ -68,7 +68,7 @@ def generate_spring_resource(resource_name: str, fields_str: str):
 
     if not base_package:
         typer.secho(
-            "❌ Error: Unable to find a valid Spring Boot project here.",
+            "Error: Unable to find a valid Spring Boot project here.",
             fg=typer.colors.RED,
         )
         raise typer.Exit(code=1)
@@ -91,7 +91,7 @@ def generate_spring_resource(resource_name: str, fields_str: str):
     env = Environment(loader=FileSystemLoader(templates_dir))
 
     typer.secho(
-        f"⚙️  Generating Spring resource '{entity_name}' (with MapStruct & DTOs)...",
+        f"Generating Spring resource '{entity_name}' (with MapStruct & DTOs)...",
         fg=typer.colors.CYAN,
     )
 
@@ -121,7 +121,7 @@ def generate_spring_resource(resource_name: str, fields_str: str):
 
         typer.echo(f"  - Created: {comp['dir']}/{target_file_name}")
 
-    typer.secho(f"✅ {entity_name} architecture successfully generated!", fg=typer.colors.GREEN)
+    typer.secho(f"{entity_name} architecture successfully generated!", fg=typer.colors.GREEN)
 
 
 def generate_spring_security(_root_path: str = "."):
@@ -133,7 +133,7 @@ def generate_spring_security(_root_path: str = "."):
 
     if not base_package:
         typer.secho(
-            "❌ Error: Unable to locate Java package for security.",
+            "Error: Unable to locate Java package for security.",
             fg=typer.colors.RED,
         )
         return
@@ -153,7 +153,7 @@ def generate_spring_security(_root_path: str = "."):
         "ApplicationConfig.java",
     ]
 
-    typer.secho(f"🛡️  Injecting JWT security into {base_package}.config...", fg=typer.colors.CYAN)
+    typer.secho(f"Injecting JWT security into {base_package}.config...", fg=typer.colors.CYAN)
 
     for filename in security_files:
         template = env.get_template(f"{filename}.j2")
@@ -163,4 +163,4 @@ def generate_spring_security(_root_path: str = "."):
             f.write(content)
         typer.echo(f"  - Created: config/{filename}")
 
-    typer.secho("✅ Security initialized successfully!", fg=typer.colors.GREEN)
+    typer.secho("Security initialized successfully!", fg=typer.colors.GREEN)
diff --git a/devctl/generators/scaffold_svelte.py b/devctl/generators/scaffold_svelte.py
new file mode 100644
index 0000000..21cd384
--- /dev/null
+++ b/devctl/generators/scaffold_svelte.py
@@ -0,0 +1,73 @@
+"""
+Svelte resource scaffolding generator.
+Handles the creation of components and routes.
+"""
+
+import os
+
+import typer
+
+from devctl.orchestrator.scanner import detect_environment
+
+
+def generate_svelte_resource(resource_name: str, _fields_str: str, root_path: str = "."):
+    """
+    Scaffolds a Svelte resource (Route, Component).
+    """
+    env_state = detect_environment(root_path)
+
+    if not env_state["has_svelte"]:
+        typer.secho("❌ Error: No Svelte project detected here.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    svelte_root = env_state["svelte_path"]
+    resource_lower = resource_name.lower()
+    entity_name = resource_name.capitalize()
+
+    # Structure: src/routes/resource-name/+page.svelte
+    routes_dir = os.path.join(svelte_root, "src", "routes", resource_lower)
+    components_dir = os.path.join(svelte_root, "src", "lib", "components")
+
+    os.makedirs(routes_dir, exist_ok=True)
+    os.makedirs(components_dir, exist_ok=True)
+
+    typer.secho(f"⚙️  Generating Svelte resource '{entity_name}'...", fg=typer.colors.CYAN)
+
+    # 1. Generate +page.svelte
+    page_content = f"""<script lang="ts">
+  import {entity_name}List from '$lib/components/{entity_name}List.svelte';
+</script>
+
+<h1>{entity_name} Management</h1>
+
+<{entity_name}List />
+"""
+    with open(os.path.join(routes_dir, "+page.svelte"), "w") as f:
+        f.write(page_content)
+
+    # 2. Generate Component
+    component_content = f"""<script lang="ts">
+  export let items = [];
+</script>
+
+<div class="list">
+  <h2>{entity_name} List</h2>
+  <p>Generated by devctl</p>
+  <ul>
+    <li>Sample Item</li>
+  </ul>
+</div>
+
+<style>
+  .list {{
+    padding: 1rem;
+    border: 1px solid #ccc;
+  }}
+</style>
+"""
+    with open(os.path.join(components_dir, f"{entity_name}List.svelte"), "w") as f:
+        f.write(component_content)
+
+    typer.secho(f"✅ {entity_name} Svelte feature successfully generated!", fg=typer.colors.GREEN)
+    typer.echo(f"  - Created: src/routes/{resource_lower}/+page.svelte")
+    typer.echo(f"  - Created: src/lib/components/{entity_name}List.svelte")
diff --git a/devctl/generators/scaffold_vue.py b/devctl/generators/scaffold_vue.py
index 414c071..98db469 100644
--- a/devctl/generators/scaffold_vue.py
+++ b/devctl/generators/scaffold_vue.py
@@ -19,7 +19,7 @@ def generate_vue_resource(resource_name: str, fields_str: str, root_path: str =
     env_state = detect_environment(root_path)
 
     if not env_state["has_vue"]:
-        typer.secho("❌ Error: No Vue.js project detected here.", fg=typer.colors.RED)
+        typer.secho("Error: No Vue.js project detected here.", fg=typer.colors.RED)
         raise typer.Exit(code=1)
 
     vue_root = env_state["vue_path"]
@@ -74,7 +74,7 @@ def generate_vue_resource(resource_name: str, fields_str: str, root_path: str =
         autoescape=select_autoescape(["html", "xml"]),
     )
 
-    typer.secho(f"⚙️  Generating Vue.js feature '{entity_name}'...", fg=typer.colors.CYAN)
+    typer.secho(f"Generating Vue.js feature '{entity_name}'...", fg=typer.colors.CYAN)
 
     # Template data
     context = {
@@ -106,6 +106,6 @@ def generate_vue_resource(resource_name: str, fields_str: str, root_path: str =
             typer.echo(f"  - Created: {display_dir}/{target_file_name}")
 
         except Exception as e:
-            typer.secho(f"⚠️  Error on {comp['template']}: {e}", fg=typer.colors.YELLOW)
+            typer.secho(f"Warning: Error on {comp['template']}: {e}", fg=typer.colors.YELLOW)
 
-    typer.secho(f"✅ {entity_name} Vue feature successfully generated!", fg=typer.colors.GREEN)
+    typer.secho(f"{entity_name} Vue feature successfully generated!", fg=typer.colors.GREEN)
diff --git a/devctl/generators/spring.py b/devctl/generators/spring.py
index 39cdade..be8e17b 100644
--- a/devctl/generators/spring.py
+++ b/devctl/generators/spring.py
@@ -146,7 +146,7 @@ def download_spring_boilerplate(project_name: str, db_type: str = "postgres"):
     Automatically makes the Maven wrapper executable on Unix.
     """
     typer.secho(
-        f"🔄 Generating Spring Boot backend '{project_name}' (Driver: {db_type})...",
+        f"Generating Spring Boot backend '{project_name}' (Driver: {db_type})...",
         fg=typer.colors.CYAN,
     )
 
@@ -188,7 +188,7 @@ def download_spring_boilerplate(project_name: str, db_type: str = "postgres"):
         response = requests.get(url, params=params)
 
         if response.status_code != 200:
-            typer.secho(f"❌ API Rejected: {response.text}", fg=typer.colors.RED)
+            typer.secho(f"Error: API Rejected: {response.text}", fg=typer.colors.RED)
             return False
 
         z = zipfile.ZipFile(io.BytesIO(response.content))
@@ -211,11 +211,11 @@ def download_spring_boilerplate(project_name: str, db_type: str = "postgres"):
         os.chdir("..")
 
         typer.secho(
-            f"✅ Backend successfully generated in folder ./{project_name}!",
+            f"Backend successfully generated in folder ./{project_name}!",
             fg=typer.colors.GREEN,
         )
         return True
 
     except requests.exceptions.RequestException as e:
-        typer.secho(f"❌ Network error contacting API: {e}", fg=typer.colors.RED)
+        typer.secho(f"Error: Network error contacting API: {e}", fg=typer.colors.RED)
         return False
diff --git a/devctl/generators/svelte.py b/devctl/generators/svelte.py
new file mode 100644
index 0000000..d3c7563
--- /dev/null
+++ b/devctl/generators/svelte.py
@@ -0,0 +1,52 @@
+"""
+Generators for Svelte projects.
+Includes boilerplate generation via create-svelte.
+"""
+
+import os
+import subprocess
+
+import typer
+
+
+def generate_svelte_boilerplate(project_name: str) -> bool:
+    """
+    Generates a new SvelteKit project using create-svelte via npx.
+    """
+    typer.secho(f"Generating Svelte project '{project_name}'...", fg=typer.colors.CYAN)
+    safe_name = project_name.lower().replace("_", "-")
+
+    try:
+        typer.secho("Scaffolding SvelteKit project...", fg=typer.colors.CYAN)
+        # Using a non-interactive way to scaffold svelte
+        # We'll use the 'skeleton' template with TypeScript
+        subprocess.run(
+            [
+                "npx",
+                "sv",
+                "create",
+                safe_name,
+                "--template",
+                "skeleton",
+                "--types",
+                "typescript",
+                "--no-install",
+                "--no-git",
+            ],
+            check=True,
+        )
+
+        project_full_path = os.path.join(os.getcwd(), safe_name)
+
+        typer.secho("Installing npm dependencies...", fg=typer.colors.CYAN)
+        subprocess.run(["npm", "install"], cwd=project_full_path, check=True)
+
+        typer.secho(f"Svelte project '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
+        return True
+
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"Error: Svelte creation failed with code: {e.returncode}", fg=typer.colors.RED)
+        return False
+    except Exception as e:
+        typer.secho(f"Error: Svelte initialization failed: {e}", fg=typer.colors.RED)
+        return False
diff --git a/devctl/generators/vue.py b/devctl/generators/vue.py
index 439d581..dcd7280 100644
--- a/devctl/generators/vue.py
+++ b/devctl/generators/vue.py
@@ -14,7 +14,7 @@ def setup_vue_proxy(project_path: str):
     """
     Replaces the default vite.config.ts with our version including the proxy.
     """
-    typer.secho("⚙️  Configuring Vite Proxy for Spring Boot...", fg=typer.colors.CYAN)
+    typer.secho("Configuring Vite Proxy for Spring Boot...", fg=typer.colors.CYAN)
 
     templates_dir = os.path.join(os.path.dirname(__file__), "..", "templates", "vue", "config")
     env = Environment(loader=FileSystemLoader(templates_dir))
@@ -28,14 +28,14 @@ def setup_vue_proxy(project_path: str):
             f.write(content)
         typer.echo("  - vite.config.ts updated with /api proxy.")
     except Exception as e:
-        typer.secho(f"⚠️  Error configuring proxy: {e}", fg=typer.colors.YELLOW)
+        typer.secho(f"Warning: Error configuring proxy: {e}", fg=typer.colors.YELLOW)
 
 
 def setup_vue_router(project_path: str):
     """
     Installs vue-router and configures the base architecture (main.ts, router, App.vue).
     """
-    typer.secho("🛣️  Installing and configuring vue-router...", fg=typer.colors.CYAN)
+    typer.secho("Installing and configuring vue-router...", fg=typer.colors.CYAN)
 
     try:
         # 1. NPM package installation
@@ -69,25 +69,25 @@ def setup_vue_router(project_path: str):
 
         typer.echo("  - Navigation architecture ready.")
     except Exception as e:
-        typer.secho(f"⚠️  Error configuring router: {e}", fg=typer.colors.YELLOW)
+        typer.secho(f"Warning: Error configuring router: {e}", fg=typer.colors.YELLOW)
 
 
 def generate_vue_boilerplate(project_name: str) -> bool:
     """
     Generates a Vue 3 + TypeScript project via Vite.
     """
-    typer.secho(f"🔄 Generating Vue.js frontend '{project_name}' via Vite...", fg=typer.colors.CYAN)
+    typer.secho(f"Generating Vue.js frontend '{project_name}' via Vite...", fg=typer.colors.CYAN)
     safe_name = project_name.lower().replace("_", "-")
 
     try:
-        typer.secho("📦 Scaffolding Vite project...", fg=typer.colors.CYAN)
+        typer.secho("Scaffolding Vite project...", fg=typer.colors.CYAN)
         subprocess.run(
             ["npm", "create", "vite@latest", safe_name, "--", "--template", "vue-ts"], check=True
         )
 
         project_full_path = os.path.join(os.getcwd(), safe_name)
 
-        typer.secho("⏳ Installing npm dependencies...", fg=typer.colors.CYAN)
+        typer.secho("Installing npm dependencies...", fg=typer.colors.CYAN)
         subprocess.run(["npm", "install"], cwd=project_full_path, check=True)
 
         # --- CALL OUR TWO CONFIGURATORS ---
@@ -95,11 +95,11 @@ def generate_vue_boilerplate(project_name: str) -> bool:
         setup_vue_router(project_full_path)
         # ----------------------------------------
 
-        typer.secho(
-            f"✅ Vue.js frontend '{safe_name}' successfully generated!", fg=typer.colors.GREEN
-        )
+        typer.secho(f"Vue.js frontend '{safe_name}' successfully generated!", fg=typer.colors.GREEN)
         return True
 
     except subprocess.CalledProcessError as e:
-        typer.secho(f"❌ Vue/Vite process failed with code: {e.returncode}", fg=typer.colors.RED)
+        typer.secho(
+            f"Error: Vue/Vite process failed with code: {e.returncode}", fg=typer.colors.RED
+        )
         return False
diff --git a/devctl/orchestrator/config_builder.py b/devctl/orchestrator/config_builder.py
index c148225..d58dbbc 100644
--- a/devctl/orchestrator/config_builder.py
+++ b/devctl/orchestrator/config_builder.py
@@ -18,7 +18,14 @@ def generate_config(project_name: str, db_type: str = "postgres", custom_port: i
 
     # Intelligent default port resolution
     if custom_port is None:
-        db_port = 5432 if db_type == "postgres" else 3306
+        if db_type == "postgres":
+            db_port = 5432
+        elif db_type == "mysql":
+            db_port = 3306
+        elif db_type == "mongodb":
+            db_port = 27017
+        else:
+            db_port = 5432
     else:
         db_port = custom_port
 
@@ -48,10 +55,10 @@ def generate_config(project_name: str, db_type: str = "postgres", custom_port: i
                 f.write(props_template.render(context))
 
         typer.secho(
-            f"⚙️  Dynamic configuration ({db_type} on port {db_port}) generated.",
+            f"Dynamic configuration ({db_type} on port {db_port}) generated.",
             fg=typer.colors.GREEN,
         )
         return True
     except Exception as e:
-        typer.secho(f"❌ Configuration error: {e}", fg=typer.colors.RED)
+        typer.secho(f"Error: Configuration failed: {e}", fg=typer.colors.RED)
         return False
diff --git a/devctl/orchestrator/runner.py b/devctl/orchestrator/runner.py
index 1d1a114..0efea81 100644
--- a/devctl/orchestrator/runner.py
+++ b/devctl/orchestrator/runner.py
@@ -1,19 +1,31 @@
 """
 Local development environment runner.
-Handles parallel process management for multi-tier applications.
+Handles parallel process management for multi-tier applications with log prefixing.
 """
 
+import os
+import signal
 import subprocess
 import sys
+import threading
 import time
+from pathlib import Path
+from typing import List
 
 import typer
+from rich.console import Console
+
+from devctl.generators.docker_scaffold import DockerProject
+
+console = Console()
+
+# Global list to track processes for cleanup
+active_processes = []
+active_threads = []
 
 
 def is_docker_running():
-    """
-    Checks if the Docker daemon is active on the system.
-    """
+    """Checks if the Docker daemon is active on the system."""
     try:
         subprocess.run(["docker", "info"], capture_output=True, check=True)
         return True
@@ -21,120 +33,253 @@ def is_docker_running():
         return False
 
 
-def launch_dev_environment(env_state: dict):
+def stream_logs(name: str, process: subprocess.Popen, color: str):
+    """Streams logs from a process with a colored prefix."""
+    try:
+        # Use line-buffered reading
+        for line in iter(process.stdout.readline, b""):
+            if line:
+                decoded_line = line.decode("utf-8", errors="ignore").rstrip()
+                console.print(f"[{color}]{name:>15} |[/{color}] {decoded_line}")
+    except Exception as e:
+        console.print(f"[red]Error streaming logs for {name}: {e}[/red]")
+
+
+def launch_dev_environment(projects: List[DockerProject], docker_composes: List[Path]):
     """
-    Launches the necessary processes in parallel (Optimized for Linux/Fedora).
+    Launches the necessary processes in parallel with structured startup and log streaming.
     """
-    processes = []
+    global active_processes
+
+    def signal_handler(_sig, _frame):
+        typer.echo("\nShutdown requested. Cleaning up...")
+        cleanup_and_exit(docker_composes)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
 
     try:
-        # 4. Launch Vue.js Frontend
-        if env_state.get("has_vue"):
+        # 1. Start Databases
+        if docker_composes:
+            if not is_docker_running():
+                typer.secho("Error: Docker service is not running.", fg=typer.colors.RED)
+                sys.exit(1)
+
+            for compose_path in docker_composes:
+                typer.secho(f"Starting Docker Compose in {compose_path}...", fg=typer.colors.CYAN)
+                subprocess.run(["docker", "compose", "up", "-d"], cwd=str(compose_path), check=True)
+
+            typer.echo("Waiting 5s for databases to initialize...")
+            time.sleep(5)
+
+        # 2. Start Backends (Spring Boot)
+        backends = [p for p in projects if p.kind == "spring"]
+        for p in backends:
+            typer.secho(f"Starting Spring Boot: {p.name}...", fg=typer.colors.GREEN)
+
+            proc = subprocess.Popen(
+                ["./mvnw", "spring-boot:run"],
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
+            )
+            active_processes.append((p.name, proc))
+
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, "green"), daemon=True)
+            t.start()
+            active_threads.append(t)
+
+        # 3. Start Frontends (Angular / Vue / React / NextJS / Svelte)
+        frontends = [
+            p for p in projects if p.kind in ["angular", "vue", "react", "nextjs", "svelte"]
+        ]
+        for p in frontends:
+            if p.kind == "angular":
+                color = "cyan"
+                cmd = ["npx", "ng", "serve"]
+            elif p.kind == "vue":
+                color = "magenta"
+                cmd = ["npm", "run", "dev"]
+            elif p.kind == "react":
+                color = "blue"
+                cmd = ["npm", "run", "dev"]
+            elif p.kind == "nextjs":
+                color = "yellow"
+                cmd = ["npm", "run", "dev"]
+            else:  # svelte
+                color = "red"
+                cmd = ["npm", "run", "dev"]
+
             typer.secho(
-                f"🟢 Starting Vue.js from {env_state['vue_path']}...", fg=typer.colors.GREEN
+                f"Starting {p.kind.capitalize()}: {p.name}...",
+                fg=getattr(typer.colors, color.upper()),
             )
 
-            p_vue = subprocess.Popen(
-                ["npm", "run", "dev"],  # Standard Vite command
-                cwd=env_state["vue_path"],
+            proc = subprocess.Popen(
+                cmd,
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
             )
-            processes.append(("Vue.js", p_vue))
+            active_processes.append((p.name, proc))
 
-        # 1. Launch Database
-        if env_state["has_docker_compose"]:
-            if not is_docker_running():
-                typer.secho("❌ Error: Docker service is not running.", fg=typer.colors.RED)
-                typer.echo("💡 Hint: sudo systemctl start docker")
-                sys.exit(1)
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, color), daemon=True)
+            t.start()
+            active_threads.append(t)
 
-            typer.secho(
-                f"🐳 Starting Docker from {env_state['docker_path']}...", fg=typer.colors.CYAN
+        # 4. Start NestJS Backends
+        nest_apps = [p for p in projects if p.kind == "nest"]
+        for p in nest_apps:
+            typer.secho(f"Starting NestJS: {p.name}...", fg=typer.colors.MAGENTA)
+
+            proc = subprocess.Popen(
+                ["npm", "run", "start:dev"],
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
             )
-            subprocess.run(
-                ["docker", "compose", "up", "-d"], cwd=env_state["docker_path"], check=True
+            active_processes.append((p.name, proc))
+
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, "magenta"), daemon=True)
+            t.start()
+            active_threads.append(t)
+
+        # 5. Start NodeJS/Express Backends
+        nodejs_apps = [p for p in projects if p.kind == "nodejs"]
+        for p in nodejs_apps:
+            typer.secho(f"Starting NodeJS: {p.name}...", fg=typer.colors.GREEN)
+
+            proc = subprocess.Popen(
+                ["npm", "run", "dev"],
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
             )
-            time.sleep(5)
+            active_processes.append((p.name, proc))
 
-            # 2. Launch Spring Boot Backend
-        if env_state["has_spring"]:
-            typer.secho(
-                f"🍃 Starting Spring Boot from {env_state['spring_path']}...",
-                fg=typer.colors.GREEN,
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, "green"), daemon=True)
+            t.start()
+            active_threads.append(t)
+
+        # 6. Start FastAPI Backends
+        fastapi_apps = [p for p in projects if p.kind == "fastapi"]
+        for p in fastapi_apps:
+            typer.secho(f"Starting FastAPI: {p.name}...", fg=typer.colors.CYAN)
+
+            # Use venv if exists
+            venv_python = os.path.join(str(p.path), ".venv", "bin", "python3")
+            if not os.path.exists(venv_python):
+                venv_python = "python3"
+
+            proc = subprocess.Popen(
+                [venv_python, "-m", "uvicorn", "main:app", "--reload"],
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
             )
+            active_processes.append((p.name, proc))
 
-            # Native Linux execution
-            p_spring = subprocess.Popen(["./mvnw", "spring-boot:run"], cwd=env_state["spring_path"])
-            processes.append(("Spring Boot", p_spring))
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, "cyan"), daemon=True)
+            t.start()
+            active_threads.append(t)
 
-        # 3. Launch Angular Frontend
-        if env_state["has_angular"]:
-            typer.secho(
-                f"🅰️ Starting Angular from {env_state['angular_path']}...", fg=typer.colors.CYAN
+        # 7. Start Django Backends
+        django_apps = [p for p in projects if p.kind == "django"]
+        for p in django_apps:
+            typer.secho(f"Starting Django: {p.name}...", fg=typer.colors.GREEN)
+
+            venv_python = os.path.join(str(p.path), ".venv", "bin", "python3")
+            if not os.path.exists(venv_python):
+                venv_python = "python3"
+
+            proc = subprocess.Popen(
+                [venv_python, "manage.py", "runserver"],
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
+            )
+            active_processes.append((p.name, proc))
+
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, "green"), daemon=True)
+            t.start()
+            active_threads.append(t)
+
+        # 8. Start Go Backends
+        go_apps = [p for p in projects if p.kind == "go"]
+        for p in go_apps:
+            typer.secho(f"Starting Go: {p.name}...", fg=typer.colors.CYAN)
+
+            proc = subprocess.Popen(
+                ["go", "run", "."],
+                cwd=str(p.path),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=1,
             )
+            active_processes.append((p.name, proc))
 
-            # Native Linux execution
-            p_angular = subprocess.Popen(["npx", "ng", "serve"], cwd=env_state["angular_path"])
-            processes.append(("Angular", p_angular))
+            t = threading.Thread(target=stream_logs, args=(p.name, proc, "cyan"), daemon=True)
+            t.start()
+            active_threads.append(t)
 
-        if not processes and not env_state["has_docker_compose"]:
+        if not active_processes and not docker_composes:
             typer.secho(
-                "⚠️ No Spring, Angular, Vue.js or DB project detected in this tree.",
-                fg=typer.colors.YELLOW,
+                "Warning: No projects or databases detected to run.", fg=typer.colors.YELLOW
             )
             return
 
         typer.secho(
-            "\n✨ Development environment active! Press Ctrl+C to stop everything gracefully.\n",
+            "\nDevelopment environment active! Press Ctrl+C to stop everything gracefully.\n",
             fg=typer.colors.GREEN,
             bold=True,
         )
 
+        # Keep the main thread alive
         while True:
-            # Monitor process health
-            for name, p in processes:
-                exit_code = p.poll()
-                if exit_code is not None:
+            time.sleep(1)
+            # Check if any process has died unexpectedly
+            for name, proc in active_processes:
+                if proc.poll() is not None:
                     typer.secho(
-                        f"\n❌ Critical Error: {name} process terminated unexpectedly "
-                        f"(Exit code: {exit_code}).",
+                        f"Warning: Process {name} exited with code {proc.returncode}",
                         fg=typer.colors.RED,
-                        bold=True,
                     )
-                    # Trigger shutdown logic
-                    raise KeyboardInterrupt
+                    active_processes.remove((name, proc))
 
-            time.sleep(1)
+    except Exception as e:
+        typer.secho(f"Error: A system error occurred: {e}", fg=typer.colors.RED)
+        cleanup_and_exit(docker_composes)
 
-    except KeyboardInterrupt:
-        typer.secho(
-            "\n🛑 Shutdown requested. Performing full cleanup (Please wait, "
-            "do not press Ctrl+C again)...",
-            fg=typer.colors.YELLOW,
-            bold=True,
-        )
 
-        for name, p in processes:
-            typer.echo(f"Closing {name}...")
-            p.terminate()
-            p.wait()
-
-        if env_state["has_docker_compose"]:
-            typer.echo("Destroying database and Docker volumes...")
-            try:
-                subprocess.run(
-                    ["docker", "compose", "down", "-v"],
-                    cwd=env_state["docker_path"],
-                    check=True,
-                    stdout=subprocess.DEVNULL,
-                )
-            except subprocess.CalledProcessError:
-                typer.secho(
-                    "⚠️ Warning: Docker cleanup did not complete correctly.",
-                    fg=typer.colors.RED,
-                )
-
-        typer.secho("✅ Cleanup finished. Environment is perfectly clean.", fg=typer.colors.GREEN)
-        sys.exit(0)
+def cleanup_and_exit(docker_composes: List[Path]):
+    """Stops all active processes and docker containers."""
+    for name, proc in active_processes:
+        typer.echo(f"Closing {name}...")
+        proc.terminate()
+        try:
+            proc.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            typer.echo(f"Force killing {name}...")
+            proc.kill()
 
-    except Exception as e:
-        typer.secho(f"❌ A system error occurred: {e}", fg=typer.colors.RED)
+    for compose_path in docker_composes:
+        typer.echo(f"Stopping Docker Compose in {compose_path}...")
+        try:
+            subprocess.run(
+                ["docker", "compose", "down", "-v"],
+                cwd=str(compose_path),
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except Exception:
+            typer.secho(f"Warning: Docker cleanup failed for {compose_path}", fg=typer.colors.RED)
+
+    typer.secho("Cleanup finished. Environment is clean.", fg=typer.colors.GREEN)
+    sys.exit(0)
diff --git a/devctl/orchestrator/scanner.py b/devctl/orchestrator/scanner.py
index 1b378ca..dfa566e 100644
--- a/devctl/orchestrator/scanner.py
+++ b/devctl/orchestrator/scanner.py
@@ -1,8 +1,10 @@
 """
 Project scanner and environment detector.
-Identifies Spring Boot, Angular, Vue.js, and Docker components in a directory tree.
+Identifies Spring Boot, Angular, Vue.js, React, NextJS, NestJS, NodeJS, FastAPI,
+Django, Svelte, Go, and Docker components in a directory tree.
 """
 
+import json
 import os
 from pathlib import Path
 
@@ -17,6 +19,8 @@
     "venv",
     ".venv",
     "__pycache__",
+    ".next",
+    ".svelte-kit",
 }
 
 
@@ -35,6 +39,22 @@ def detect_environment(root_path: str = "."):
         "angular_path": None,
         "has_vue": False,
         "vue_path": None,
+        "has_react": False,
+        "react_path": None,
+        "has_nextjs": False,
+        "nextjs_path": None,
+        "has_nest": False,
+        "nest_path": None,
+        "has_nodejs": False,
+        "nodejs_path": None,
+        "has_fastapi": False,
+        "fastapi_path": None,
+        "has_django": False,
+        "django_path": None,
+        "has_svelte": False,
+        "svelte_path": None,
+        "has_go": False,
+        "go_path": None,
         "project_root": str(root),
     }
 
@@ -60,12 +80,75 @@ def detect_environment(root_path: str = "."):
             env_state["has_angular"] = True
             env_state["angular_path"] = str(current_path)
 
-        # 4. Vue.js (Vite) detection
+        # 4. Vite-based detection (Vue/React)
         vue_markers = {"vite.config.ts", "vite.config.js"}
-        if (vue_markers & filename_set) and not env_state["has_vue"]:
-            # Special case: don't shadow Angular if it also has a vite config (unlikely but safe)
-            if not env_state["has_angular"]:
+        if (vue_markers & filename_set) and not any([env_state["has_vue"], env_state["has_react"]]):
+            # Distinguish by package.json
+            pkg_path = current_path / "package.json"
+            if pkg_path.exists():
+                try:
+                    pkg = json.loads(pkg_path.read_text(encoding="utf-8"))
+                    deps = pkg.get("dependencies", {})
+                    dev_deps = pkg.get("devDependencies", {})
+                    all_deps = {**deps, **dev_deps}
+                    if "react" in all_deps:
+                        env_state["has_react"] = True
+                        env_state["react_path"] = str(current_path)
+                    else:
+                        env_state["has_vue"] = True
+                        env_state["vue_path"] = str(current_path)
+                except Exception:
+                    env_state["has_vue"] = True
+                    env_state["vue_path"] = str(current_path)
+            else:
                 env_state["has_vue"] = True
                 env_state["vue_path"] = str(current_path)
 
+        # 5. NestJS detection
+        if "nest-cli.json" in filename_set and not env_state["has_nest"]:
+            env_state["has_nest"] = True
+            env_state["nest_path"] = str(current_path)
+
+        # 6. NextJS detection
+        if any(f.startswith("next.config.") for f in filename_set) and not env_state["has_nextjs"]:
+            env_state["has_nextjs"] = True
+            env_state["nextjs_path"] = str(current_path)
+
+        # 7. Generic NodeJS detection (if not already caught)
+        if "package.json" in filename_set and not any(
+            [
+                env_state["has_angular"],
+                env_state["has_vue"],
+                env_state["has_react"],
+                env_state["has_nest"],
+                env_state["has_nextjs"],
+            ]
+        ):
+            env_state["has_nodejs"] = True
+            env_state["nodejs_path"] = str(current_path)
+
+        # 8. Python detection (FastAPI/Django)
+        if "requirements.txt" in filename_set:
+            req_path = current_path / "requirements.txt"
+            try:
+                req_content = req_path.read_text().lower()
+                if "fastapi" in req_content and not env_state["has_fastapi"]:
+                    env_state["has_fastapi"] = True
+                    env_state["fastapi_path"] = str(current_path)
+                if "django" in req_content and not env_state["has_django"]:
+                    env_state["has_django"] = True
+                    env_state["django_path"] = str(current_path)
+            except Exception:
+                pass
+
+        # 9. Svelte detection
+        if "svelte.config.js" in filename_set and not env_state["has_svelte"]:
+            env_state["has_svelte"] = True
+            env_state["svelte_path"] = str(current_path)
+
+        # 10. Go detection
+        if "go.mod" in filename_set and not env_state["has_go"]:
+            env_state["has_go"] = True
+            env_state["go_path"] = str(current_path)
+
     return env_state
diff --git a/devctl/templates/docker/django/Dockerfile.j2 b/devctl/templates/docker/django/Dockerfile.j2
new file mode 100644
index 0000000..4170620
--- /dev/null
+++ b/devctl/templates/docker/django/Dockerfile.j2
@@ -0,0 +1,21 @@
+# Production Dockerfile for Django
+# Generated by devctl
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apk add --no-cache libpq-dev gcc
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+# Using gunicorn for production
+RUN pip install gunicorn
+
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "core.wsgi:application"]
diff --git a/devctl/templates/docker/fastapi/Dockerfile.j2 b/devctl/templates/docker/fastapi/Dockerfile.j2
new file mode 100644
index 0000000..15bba2c
--- /dev/null
+++ b/devctl/templates/docker/fastapi/Dockerfile.j2
@@ -0,0 +1,15 @@
+# Production Dockerfile for FastAPI
+# Generated by devctl
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
diff --git a/devctl/templates/docker/go/Dockerfile.j2 b/devctl/templates/docker/go/Dockerfile.j2
new file mode 100644
index 0000000..e3a806f
--- /dev/null
+++ b/devctl/templates/docker/go/Dockerfile.j2
@@ -0,0 +1,24 @@
+# Production Dockerfile for Go (Fiber)
+# Generated by devctl
+
+# Stage 1: Build
+FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -o main .
+
+# Stage 2: Run
+FROM alpine:latest
+
+WORKDIR /app
+
+COPY --from=builder /app/main .
+
+EXPOSE 3000
+
+CMD ["./main"]
diff --git a/devctl/templates/docker/nestjs/Dockerfile.j2 b/devctl/templates/docker/nestjs/Dockerfile.j2
new file mode 100644
index 0000000..007b6fa
--- /dev/null
+++ b/devctl/templates/docker/nestjs/Dockerfile.j2
@@ -0,0 +1,26 @@
+# Production Dockerfile for NestJS
+# Generated by devctl
+
+# Stage 1: Build
+FROM node:{{ project.node_version }}-alpine AS builder
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+# Stage 2: Run
+FROM node:{{ project.node_version }}-alpine
+
+WORKDIR /app
+
+COPY --from=builder /app/package*.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+
+EXPOSE 3000
+
+CMD ["node", "dist/main"]
diff --git a/devctl/templates/docker/nextjs/Dockerfile.j2 b/devctl/templates/docker/nextjs/Dockerfile.j2
new file mode 100644
index 0000000..263b2b3
--- /dev/null
+++ b/devctl/templates/docker/nextjs/Dockerfile.j2
@@ -0,0 +1,43 @@
+# Production Dockerfile for NextJS
+# Generated by devctl
+
+FROM node:{{ project.node_version }}-alpine AS base
+
+# 1. Install dependencies only when needed
+FROM base AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+
+# 2. Rebuild the source code only when needed
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+# 3. Production image, copy all the files and run next
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nextjs -u 1001
+
+COPY --from=builder /app/public ./public
+
+# Automatically leverage output traces to reduce image size
+# https://nextjs.org/docs/advanced-features/output-file-tracing
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+USER nextjs
+
+EXPOSE 3000
+
+ENV PORT=3000
+ENV HOSTNAME="0.0.0.0"
+
+CMD ["node", "server.js"]
diff --git a/devctl/templates/docker/nodejs/Dockerfile.j2 b/devctl/templates/docker/nodejs/Dockerfile.j2
new file mode 100644
index 0000000..c1be50d
--- /dev/null
+++ b/devctl/templates/docker/nodejs/Dockerfile.j2
@@ -0,0 +1,24 @@
+# Production Dockerfile for NodeJS/Express
+# Generated by devctl
+
+FROM node:{{ project.node_version }}-alpine AS builder
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+FROM node:{{ project.node_version }}-alpine
+
+WORKDIR /app
+
+COPY --from=builder /app/package*.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+
+EXPOSE 3000
+
+CMD ["npm", "start"]
diff --git a/devctl/templates/docker/svelte/Dockerfile.j2 b/devctl/templates/docker/svelte/Dockerfile.j2
new file mode 100644
index 0000000..d5e57be
--- /dev/null
+++ b/devctl/templates/docker/svelte/Dockerfile.j2
@@ -0,0 +1,24 @@
+# Production Dockerfile for SvelteKit
+# Generated by devctl
+
+FROM node:{{ project.node_version }}-alpine AS builder
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+FROM node:{{ project.node_version }}-alpine
+
+WORKDIR /app
+
+COPY --from=builder /app/package*.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/build ./build
+
+EXPOSE 3000
+
+CMD ["node", "build"]
diff --git a/devctl/templates/spring/application.properties.j2 b/devctl/templates/spring/application.properties.j2
index 3132dec..35a6909 100644
--- a/devctl/templates/spring/application.properties.j2
+++ b/devctl/templates/spring/application.properties.j2
@@ -11,6 +11,8 @@ spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
 {% elif db_type == 'mysql' %}
 spring.datasource.url=jdbc:mysql://localhost:{{ db_port }}/{{ db_name }}
 spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
+{% elif db_type == 'mongodb' %}
+spring.data.mongodb.uri=mongodb://{{ db_user }}:{{ db_password }}@localhost:{{ db_port }}/{{ db_name }}?authSource=admin
 {% endif %}
 
 application.security.jwt.secret-key={{ jwt_secret|default('404E635266556A586E3272357538782F413F4428472B4B6250645367566B5970') }}
diff --git a/devctl/templates/spring/docker-compose.yml.j2 b/devctl/templates/spring/docker-compose.yml.j2
index 5f5effd..79edd35 100644
--- a/devctl/templates/spring/docker-compose.yml.j2
+++ b/devctl/templates/spring/docker-compose.yml.j2
@@ -13,11 +13,17 @@ services:
       MYSQL_DATABASE: {{ db_name }}
       MYSQL_USER: {{ db_user }}
       MYSQL_PASSWORD: {{ db_password }}
+    {% elif db_type == 'mongodb' %}
+    image: mongo:6.0
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: {{ db_user }}
+      MONGO_INITDB_ROOT_PASSWORD: {{ db_password }}
+      MONGO_INITDB_DATABASE: {{ db_name }}
     {% endif %}
     ports:
-      - "{{ db_port }}:{% if db_type == 'postgres' %}5432{% else %}3306{% endif %}"
+      - "{{ db_port }}:{% if db_type == 'postgres' %}5432{% elif db_type == 'mysql' %}3306{% else %}27017{% endif %}"
     volumes:
-      - {{ db_name }}_data:/var/lib/{% if db_type == 'postgres' %}postgresql{% else %}mysql{% endif %}/data
+      - {{ db_name }}_data:{% if db_type == 'postgres' %}/var/lib/postgresql/data{% elif db_type == 'mysql' %}/var/lib/mysql/data{% else %}/data/db{% endif %}
 
 volumes:
   {{ db_name }}_data:
\ No newline at end of file
diff --git a/devctl/utils/dependencies.py b/devctl/utils/dependencies.py
index e2d14a1..132b690 100644
--- a/devctl/utils/dependencies.py
+++ b/devctl/utils/dependencies.py
@@ -15,7 +15,7 @@ def check_tool(tool_name: str, required_for: str = "this operation"):
     """
     if shutil.which(tool_name) is None:
         typer.secho(
-            f"\n❌ Error: '{tool_name}' is not installed or not in your PATH.",
+            f"\nError: '{tool_name}' is not installed or not in your PATH.",
             fg=typer.colors.RED,
             bold=True,
         )
@@ -31,6 +31,6 @@ def check_tool(tool_name: str, required_for: str = "this operation"):
         }
 
         if tool_name in hints:
-            typer.echo(f"💡 Hint: {hints[tool_name]}")
+            typer.echo(f"Hint: {hints[tool_name]}")
 
         raise typer.Exit(code=1)
diff --git a/pyproject.toml b/pyproject.toml
index 4538a21..8dc4889 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devctl"
-version = "0.1.1"
+version = "1.0.0"
 description = "Local development orchestrator for Spring Boot, Angular, and Vue.js"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -23,6 +23,7 @@ dependencies = [
     "requests>=2.31.0",
     "jinja2>=3.1.3",
     "rich>=13.7.0",
+    "pyyaml>=6.0.1",
 ]
 
 [project.scripts]
diff --git a/test/test_add.py b/test/test_add.py
new file mode 100644
index 0000000..57d1d24
--- /dev/null
+++ b/test/test_add.py
@@ -0,0 +1,35 @@
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_add_resource_spring(tmp_path):
+    with patch("devctl.commands.add.detect_environment") as mock_detect:
+        mock_detect.return_value = {
+            "has_spring": True,
+            "spring_path": str(tmp_path),
+            "has_angular": False,
+        }
+        with patch("devctl.commands.add.generate_spring_resource") as mock_gen:
+            # Create a mock pom.xml so it looks like a spring project
+            (tmp_path / "pom.xml").write_text("<project></project>")
+            result = runner.invoke(app, ["add", "resource", "Product"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once()
+
+
+def test_add_resource_angular(tmp_path):
+    with patch("devctl.commands.add.detect_environment") as mock_detect:
+        mock_detect.return_value = {
+            "has_spring": False,
+            "has_angular": True,
+            "angular_path": str(tmp_path),
+        }
+        with patch("devctl.commands.add.generate_angular_resource") as mock_gen:
+            result = runner.invoke(app, ["add", "resource", "User"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once()
diff --git a/test/test_commands.py b/test/test_commands.py
index 4fa80bf..7b7c271 100644
--- a/test/test_commands.py
+++ b/test/test_commands.py
@@ -18,16 +18,14 @@ def test_init_spring_unsupported_db():
 
 def test_run_no_environment():
     """Ensure run command fails when no project is detected."""
-    with patch("devctl.commands.run.detect_environment") as mock_detect:
-        mock_detect.return_value = {
-            "has_docker_compose": False,
-            "has_spring": False,
-            "has_angular": False,
-            "has_vue": False,
-        }
-        result = runner.invoke(app, ["run"])
-        assert result.exit_code == 1
-        assert "No valid development environment detected" in result.stdout
+    with patch("devctl.commands.run.discover_docker_projects") as mock_discover:
+        mock_discover.return_value = []
+        # Also need to mock Path.rglob or something to avoid finding docker-compose.yml
+        with patch("devctl.commands.run.Path.rglob") as mock_rglob:
+            mock_rglob.return_value = []
+            result = runner.invoke(app, ["run"])
+            assert result.exit_code == 1
+            assert "No valid development environment detected" in result.stdout
 
 
 def test_add_resource_no_project():
@@ -43,7 +41,7 @@ def test_dockerize_no_project(tmp_path):
     """Ensure dockerize fails when no supported project is detected."""
     result = runner.invoke(app, ["dockerize", str(tmp_path)])
     assert result.exit_code == 1
-    assert "No Spring Boot, Angular, or Vue/Vite project detected" in result.stdout
+    assert "Error: No supported project detected." in result.stdout
 
 
 def test_dockerize_dry_run(tmp_path):
diff --git a/test/test_django.py b/test/test_django.py
new file mode 100644
index 0000000..a49a608
--- /dev/null
+++ b/test/test_django.py
@@ -0,0 +1,43 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_django_calls_boilerplate():
+    """Ensure init django calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_django_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "django", "my-django-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-django-app")
+
+
+def test_add_resource_django(tmp_path):
+    """Ensure add resource works in a Django project."""
+    (tmp_path / "manage.py").write_text("import os", encoding="utf-8")
+    (tmp_path / "requirements.txt").write_text("django", encoding="utf-8")
+    (tmp_path / "core").mkdir()
+
+    with patch("devctl.commands.add.generate_django_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_django(tmp_path):
+    """Ensure dockerize detects Django and generates a Dockerfile."""
+    (tmp_path / "manage.py").write_text("import os", encoding="utf-8")
+    (tmp_path / "requirements.txt").write_text("django", encoding="utf-8")
+    (tmp_path / "core").mkdir()
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert "gunicorn" in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_fastapi.py b/test/test_fastapi.py
new file mode 100644
index 0000000..d5c5d39
--- /dev/null
+++ b/test/test_fastapi.py
@@ -0,0 +1,41 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_fastapi_calls_boilerplate():
+    """Ensure init fastapi calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_fastapi_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "fastapi", "my-fast-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-fast-app")
+
+
+def test_add_resource_fastapi(tmp_path):
+    """Ensure add resource works in a FastAPI project."""
+    (tmp_path / "main.py").write_text("from fastapi import FastAPI", encoding="utf-8")
+    (tmp_path / "requirements.txt").write_text("fastapi", encoding="utf-8")
+
+    with patch("devctl.commands.add.generate_fastapi_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_fastapi(tmp_path):
+    """Ensure dockerize detects FastAPI and generates a Dockerfile."""
+    (tmp_path / "main.py").write_text("from fastapi import FastAPI", encoding="utf-8")
+    (tmp_path / "requirements.txt").write_text("fastapi", encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert '"uvicorn", "main:app"' in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_go.py b/test/test_go.py
new file mode 100644
index 0000000..371e778
--- /dev/null
+++ b/test/test_go.py
@@ -0,0 +1,40 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_go_calls_boilerplate():
+    """Ensure init go calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_go_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "go", "my-go-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-go-app")
+
+
+def test_add_resource_go(tmp_path):
+    """Ensure add resource works in a Go project."""
+    (tmp_path / "go.mod").write_text("module my-go-app", encoding="utf-8")
+
+    with patch("devctl.commands.add.generate_go_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_go(tmp_path):
+    """Ensure dockerize detects Go and generates a Dockerfile."""
+    (tmp_path / "go.mod").write_text("module my-go-app", encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert "golang" in (tmp_path / "Dockerfile").read_text()
+    assert 'CMD ["./main"]' in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_init.py b/test/test_init.py
new file mode 100644
index 0000000..6843ac7
--- /dev/null
+++ b/test/test_init.py
@@ -0,0 +1,33 @@
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_spring_success():
+    with patch("devctl.commands.init.download_spring_boilerplate", return_value=True) as mock_dl:
+        with patch("devctl.commands.init.generate_config") as mock_cfg:
+            with patch("devctl.commands.init.check_tool"):
+                result = runner.invoke(app, ["init", "spring", "test-api"])
+                assert result.exit_code == 0
+                mock_dl.assert_called_once()
+                mock_cfg.assert_called_once()
+
+
+def test_init_angular_success():
+    with patch("devctl.commands.init.generate_angular_boilerplate", return_value=True) as mock_gen:
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "angular", "test-front"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("test-front")
+
+
+def test_init_vue_success():
+    with patch("devctl.commands.init.generate_vue_boilerplate", return_value=True) as mock_gen:
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "vue", "test-vue"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("test-vue")
diff --git a/test/test_mongodb.py b/test/test_mongodb.py
new file mode 100644
index 0000000..2ad3b25
--- /dev/null
+++ b/test/test_mongodb.py
@@ -0,0 +1,39 @@
+import yaml
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_deploy_mongodb(tmp_path):
+    """Ensure deploy correctly detects and configures MongoDB."""
+    # Setup project with MongoDB properties
+    backend = tmp_path / "mongo-api"
+    backend.mkdir()
+    (backend / "pom.xml").write_text(
+        "<project><artifactId>mongo-api</artifactId></project>", encoding="utf-8"
+    )
+    props = backend / "src" / "main" / "resources"
+    props.mkdir(parents=True)
+    (props / "application.properties").write_text(
+        "spring.data.mongodb.uri=mongodb://admin:pass@localhost:27017/mydb?authSource=admin",
+        encoding="utf-8",
+    )
+
+    result = runner.invoke(app, ["deploy", str(tmp_path)])
+
+    assert result.exit_code == 0
+    compose_file = tmp_path / "docker-compose.yml"
+    assert compose_file.exists()
+
+    with open(compose_file, "r") as f:
+        config = yaml.safe_load(f)
+
+    services = config["services"]
+    assert "mydb-db" in services
+    db_service = services["mydb-db"]
+    assert db_service["image"] == "mongo:6.0"
+    assert "MONGO_INITDB_ROOT_USERNAME" in db_service["environment"]
+    assert db_service["environment"]["MONGO_INITDB_ROOT_USERNAME"] == "admin"
+    assert "27017:27017" in db_service["ports"]
diff --git a/test/test_nestjs.py b/test/test_nestjs.py
new file mode 100644
index 0000000..1ea6b14
--- /dev/null
+++ b/test/test_nestjs.py
@@ -0,0 +1,46 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_nest_calls_boilerplate():
+    """Ensure init nest calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_nest_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "nest", "my-nest-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-nest-app")
+
+
+def test_add_resource_nest(tmp_path):
+    """Ensure add resource works in a NestJS project."""
+    # Setup a mock NestJS project
+    (tmp_path / "nest-cli.json").write_text("{}", encoding="utf-8")
+
+    with patch("devctl.commands.add.generate_nest_resource") as mock_gen:
+        # We need to ensure detect_environment finds it
+        os.chdir(tmp_path)
+        try:
+            result = runner.invoke(app, ["add", "resource", "User"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once()
+        finally:
+            # Cleanup chdir if needed (though pytest tmp_path is usually fine)
+            pass
+
+
+def test_dockerize_nest(tmp_path):
+    """Ensure dockerize detects NestJS and generates a Dockerfile."""
+    (tmp_path / "nest-cli.json").write_text("{}", encoding="utf-8")
+    (tmp_path / "package.json").write_text('{"name": "nest-app"}', encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert "dist/main" in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_nextjs.py b/test/test_nextjs.py
new file mode 100644
index 0000000..a13e76a
--- /dev/null
+++ b/test/test_nextjs.py
@@ -0,0 +1,40 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_nextjs_calls_boilerplate():
+    """Ensure init nextjs calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_nextjs_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "nextjs", "my-next-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-next-app")
+
+
+def test_add_resource_nextjs(tmp_path):
+    """Ensure add resource works in a NextJS project."""
+    (tmp_path / "next.config.js").write_text("module.exports = {}", encoding="utf-8")
+
+    with patch("devctl.commands.add.generate_nextjs_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_nextjs(tmp_path):
+    """Ensure dockerize detects NextJS and generates a Dockerfile."""
+    (tmp_path / "next.config.js").write_text("module.exports = {}", encoding="utf-8")
+    (tmp_path / "package.json").write_text('{"name": "next-app"}', encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert "server.js" in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_nodejs.py b/test/test_nodejs.py
new file mode 100644
index 0000000..16916a5
--- /dev/null
+++ b/test/test_nodejs.py
@@ -0,0 +1,40 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_nodejs_calls_boilerplate():
+    """Ensure init nodejs calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_nodejs_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "nodejs", "my-node-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-node-app")
+
+
+def test_add_resource_nodejs(tmp_path):
+    """Ensure add resource works in a NodeJS project."""
+    (tmp_path / "package.json").write_text('{"name": "node-app"}', encoding="utf-8")
+    (tmp_path / "src").mkdir()
+
+    with patch("devctl.commands.add.generate_nodejs_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_nodejs(tmp_path):
+    """Ensure dockerize detects NodeJS and generates a Dockerfile."""
+    (tmp_path / "package.json").write_text('{"name": "node-app"}', encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert 'CMD ["npm", "start"]' in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_react.py b/test/test_react.py
new file mode 100644
index 0000000..fcb3429
--- /dev/null
+++ b/test/test_react.py
@@ -0,0 +1,44 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_react_calls_boilerplate():
+    """Ensure init react calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_react_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "react", "my-react-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-react-app")
+
+
+def test_add_resource_react(tmp_path):
+    """Ensure add resource works in a React project."""
+    (tmp_path / "package.json").write_text(
+        '{"dependencies": {"react": "18.2.0"}}', encoding="utf-8"
+    )
+    (tmp_path / "vite.config.ts").write_text("export default {}", encoding="utf-8")
+
+    with patch("devctl.commands.add.generate_react_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_react(tmp_path):
+    """Ensure dockerize detects React and generates a Dockerfile."""
+    (tmp_path / "package.json").write_text(
+        '{"dependencies": {"react": "18.2.0"}}', encoding="utf-8"
+    )
+    (tmp_path / "vite.config.ts").write_text("export default {}", encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
diff --git a/test/test_runner.py b/test/test_runner.py
new file mode 100644
index 0000000..705b138
--- /dev/null
+++ b/test/test_runner.py
@@ -0,0 +1,65 @@
+import subprocess
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from devctl.generators.docker_scaffold import DockerProject
+from devctl.orchestrator.runner import is_docker_running, launch_dev_environment
+
+
+def test_is_docker_running_true():
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0)
+        assert is_docker_running() is True
+
+
+def test_is_docker_running_false():
+    with patch("subprocess.run") as mock_run:
+        mock_run.side_effect = subprocess.CalledProcessError(1, "docker info")
+        assert is_docker_running() is False
+
+
+def test_launch_dev_environment_empty():
+    with patch("typer.secho") as mock_secho:
+        launch_dev_environment([], [])
+        mock_secho.assert_called_with(
+            "Warning: No projects or databases detected to run.", fg="yellow"
+        )
+
+
+@patch("subprocess.Popen")
+@patch("subprocess.run")
+@patch("time.sleep")
+def test_launch_dev_environment_complex(mock_sleep, mock_run, mock_popen):
+    # Setup mocks
+    mock_popen.return_value = MagicMock(poll=lambda: None)
+
+    projects = [
+        DockerProject(
+            kind="spring",
+            path=Path("/tmp/spring"),
+            name="api",
+            service_name="api",
+            relative_context="./api",
+        ),
+        DockerProject(
+            kind="angular",
+            path=Path("/tmp/angular"),
+            name="front",
+            service_name="front",
+            relative_context="./front",
+        ),
+    ]
+    docker_composes = [Path("/tmp/db")]
+
+    # Use an exception that is caught by launch_dev_environment to stop the loop
+    mock_sleep.side_effect = Exception("Stop Loop")
+
+    with patch("devctl.orchestrator.runner.is_docker_running", return_value=True):
+        with patch("devctl.orchestrator.runner.cleanup_and_exit") as mock_cleanup:
+            launch_dev_environment(projects, docker_composes)
+
+            # Verify Docker Compose started
+            mock_run.assert_any_call(["docker", "compose", "up", "-d"], cwd="/tmp/db", check=True)
+
+            # Verify cleanup called
+            mock_cleanup.assert_called_once()
diff --git a/test/test_svelte.py b/test/test_svelte.py
new file mode 100644
index 0000000..1725494
--- /dev/null
+++ b/test/test_svelte.py
@@ -0,0 +1,40 @@
+import os
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from devctl.main import app
+
+runner = CliRunner()
+
+
+def test_init_svelte_calls_boilerplate():
+    """Ensure init svelte calls the boilerplate generator."""
+    with patch("devctl.commands.init.generate_svelte_boilerplate") as mock_gen:
+        mock_gen.return_value = True
+        with patch("devctl.commands.init.check_tool"):
+            result = runner.invoke(app, ["init", "svelte", "my-svelte-app"])
+            assert result.exit_code == 0
+            mock_gen.assert_called_once_with("my-svelte-app")
+
+
+def test_add_resource_svelte(tmp_path):
+    """Ensure add resource works in a Svelte project."""
+    (tmp_path / "svelte.config.js").write_text("export default {}", encoding="utf-8")
+
+    with patch("devctl.commands.add.generate_svelte_resource") as mock_gen:
+        os.chdir(tmp_path)
+        result = runner.invoke(app, ["add", "resource", "User"])
+        assert result.exit_code == 0
+        mock_gen.assert_called_once()
+
+
+def test_dockerize_svelte(tmp_path):
+    """Ensure dockerize detects Svelte and generates a Dockerfile."""
+    (tmp_path / "svelte.config.js").write_text("export default {}", encoding="utf-8")
+    (tmp_path / "package.json").write_text('{"name": "svelte-app"}', encoding="utf-8")
+
+    result = runner.invoke(app, ["dockerize", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "Dockerfile").exists()
+    assert 'CMD ["node", "build"]' in (tmp_path / "Dockerfile").read_text()
diff --git a/test/test_utils.py b/test/test_utils.py
new file mode 100644
index 0000000..c72cbbb
--- /dev/null
+++ b/test/test_utils.py
@@ -0,0 +1,21 @@
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from devctl.utils.dependencies import check_tool
+
+
+def test_check_tool_success():
+    """Ensure check_tool does nothing if the tool exists."""
+    with patch("shutil.which", return_value="/usr/bin/docker"):
+        # Should not raise any exception
+        check_tool("docker")
+
+
+def test_check_tool_failure():
+    """Ensure check_tool raises Exit(1) if the tool is missing."""
+    with patch("shutil.which", return_value=None):
+        with pytest.raises(typer.Exit) as excinfo:
+            check_tool("nonexistent-tool")
+        assert excinfo.value.exit_code == 1