diff --git a/CHANGELOG.md b/CHANGELOG.md
index db8b04e..6d2209b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,104 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2025-11-17
+
+### Added
+
+- **Four-Method Command Architecture**: Clear separation of responsibilities
+  - `uvup clone <source> <target>` - Create exact 1:1 copy of an environment
+  - `uvup new <name> --template <template>` - Create new project from template with modification support
+  - `uvup sync --template <template>` - Sync current project with template
+- **Template System**: Powerful project scaffolding capabilities
+  - Python version override with `--python <version>`
+  - Package filtering with `--exclude <packages>` and `--include <packages>`
+  - Custom project path with `--path <directory>`
+  - Dry-run preview mode with `--dry-run` for all template operations
+  - Full support for `[project.optional-dependencies]` in pyproject.toml
+- **Migration from pip freeze to pyproject.toml**: Modern dependency management
+  - pyproject.toml-based configuration instead of requirements.txt
+  - Lock file support via uv.lock for reproducible builds
+  - Optional dependency groups for dev tools, testing, etc.
+- **Safety Features**:
+  - Automatic backup creation in `sync` command (pyproject.toml.backup)
+  - Automatic rollback on failure (uv lock/sync errors)
+  - Preview changes before execution with `--dry-run`
+
+### Changed
+
+- **Breaking**: Replaced `uvup copy` with `uvup clone` for clearer semantics
+- Environment structure now includes:
+  - `pyproject.toml` - Project configuration and dependencies
+  - `uv.lock` - Lock file for reproducible installs
+  - `.venv/` - Virtual environment directory
+  - `hello.py` - Optional demo file
+
+### Removed
+
+- `uvup copy` command (replaced by `uvup clone`)
+- Direct pip freeze dependency management (replaced by pyproject.toml)
+
+### Documentation
+
+- Complete command reference in docs/COMMANDS.md (570 lines)
+- Real-world usage scenarios in docs/USE_CASES.md (489 lines)
+- Updated README with four-method architecture explanation
+- Simplified Core Philosophy to concise bullet points
+- Added "Documentation" section with quick help and complete docs links
+- Updated TARGET.md with v0.2.0 status and v0.3.0 planning
+
+### Technical
+
+- Enhanced `commands/new.rs` with full template modification support
+- Enhanced `commands/sync.rs` with backup and rollback mechanism
+- Refactored `commands/copy.rs` to `commands/clone.rs`
+- Added comprehensive dry-run implementation across all template commands
+- Improved dependency filtering logic with PEP 508 specifier support
+
+## [0.1.3] - 2025-11-16
+
+### Added
+
+- `uvup copy <source> <target>` - Copy an existing environment to a new one
+- `--python <version>` flag for copy command to override Python version
+
+### Changed
+
+- Upgraded `ureq` dependency from v2.x to v3.0 for improved HTTP handling
+
+### Technical
+
+- Added `commands/copy.rs` module
+- Enhanced CLI with Copy command variant
+
+## [0.1.2] - 2025-11-16
+
+### Added
+
+- `uvup update` - Self-update command to install latest version from GitHub releases
+- `uvup update --check` - Check for updates without installing
+
+### Fixed
+
+- Shell validation in deactivate command to prevent errors when called outside shell context
+
+### Technical
+
+- Added `commands/update.rs` module
+- Added GitHub release checking and binary replacement logic
+
+## [0.1.1] - 2025-11-15
+
+### Fixed
+
+- Installation script compatibility issues on macOS and Linux
+- Build target for Linux changed from `unknown-linux-gnu` to `unknown-linux-musl` for better portability
+
+### Technical
+
+- Updated installation scripts (install.sh, install.ps1)
+- Modified build configuration for Linux releases
+
 ## [0.1.0] - 2025-11-15
 
 ### Added
@@ -35,4 +133,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - clap 4.5 - CLI framework
 - dirs 6.0 - Cross-platform directory paths
 
+[0.2.0]: https://github.com/KercyDing/uvup/compare/v0.1.3...v0.2.0
+[0.1.3]: https://github.com/KercyDing/uvup/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/KercyDing/uvup/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/KercyDing/uvup/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/KercyDing/uvup/releases/tag/v0.1.0
diff --git a/Cargo.lock b/Cargo.lock
index bdd9ae9..f0b3d91 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -856,6 +856,43 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "toml_datetime"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.22"
@@ -932,13 +969,14 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uvup"
-version = "0.1.2"
+version = "0.2.0"
 dependencies = [
  "clap",
  "dirs",
  "self-replace",
  "serde_json",
  "tempfile",
+ "toml_edit",
  "ureq",
 ]
 
@@ -1134,6 +1172,15 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
+[[package]]
+name = "winnow"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "wit-bindgen"
 version = "0.46.0"
diff --git a/Cargo.toml b/Cargo.toml
index fa91e2b..07f7c87 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uvup"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.85"
 authors = ["KercyDing"]
@@ -19,6 +19,7 @@ ureq = { version = "3.0", features = ["json"] }
 serde_json = "1.0"
 self-replace = "1.5"
 tempfile = "3.0"
+toml_edit = "0.23"
 
 [dev-dependencies]
 
diff --git a/README.md b/README.md
index 86b3976..32c5861 100644
--- a/README.md
+++ b/README.md
@@ -10,10 +10,10 @@ uvup aims to be a companion tool for uv, providing a familiar conda-like interfa
 
 ## Core Philosophy
 
-- **Enhancement, not replacement**: uvup calls uv for actual work
-- **User experience first**: Familiar commands and seamless activation
-- **Best practices**: Following proven patterns from conda and rustup
-- **Lightweight and cross-platform**: Single binary, works everywhere
+- **Enhancement, not replacement**: Calls uv for actual work
+- **Familiar interface**: Conda-like commands, seamless activation
+- **Single binary**: Lightweight and cross-platform
+- **Template-driven**: Reusable project configurations
 
 ## Installation
 
@@ -48,20 +48,23 @@ For detailed uninstallation instructions and manual removal, see [Uninstallation
 
 ## Planned Features
 
-### MVP (v0.1.0) - Completed
+### v0.2.0 - Completed
 
-- [x] `uvup init` - Shell integration (Bash, Zsh, Fish, PowerShell)
-- [x] `uvup create <name>` - Create environments
-- [x] `uvup activate <name>` - Activate environments (via shell hook)
-- [x] `uvup list` - List all environments
-- [x] `uvup remove <name>` - Remove environments
+- [x] `uvup clone <source> <target>` - Clone environments (1:1 exact copy)
+- [x] `uvup new <name> --template <template>` - Create projects from templates
+- [x] `uvup sync --template <template>` - Sync current project with template
+- [x] Template modification support (--python, --exclude, --include)
+- [x] Dry-run preview mode for all template operations
+- [x] pyproject.toml-based dependency management
+- [x] optional-dependencies support
 
 ### Future Versions
 
-- `uvup default <name>` - Set default environment (auto-activate on new terminal)
-- `uvup undefault` - Remove default environment
-- Installation via package managers (Homebrew, Scoop, Winget)
-- Enhanced `list` command with more environment details
+- Official template repository with curated project templates
+- `uvup template list` - Browse available official templates
+- Auto-download templates on first use
+- `uvup default <name>` - Set default environment
+- Package manager support (Homebrew, Scoop, Winget)
 
 ## Usage
 
@@ -73,8 +76,6 @@ uvup create myproject
 
 # Create with specific Python version
 uvup create myproject --python 3.12
-# or
-uvup create --python 3.12 myproject
 
 # List all environments
 uvup list
@@ -83,7 +84,7 @@ uvup list
 uvup activate myproject
 
 # Install packages (using uv)
-uv pip install numpy pandas
+uv add numpy pandas
 
 # Deactivate
 uvup deactivate
@@ -92,9 +93,113 @@ uvup deactivate
 uvup remove myproject
 ```
 
+### Environment Cloning
+
+Clone an existing environment to create an exact 1:1 copy:
+
+```bash
+# Clone an environment
+uvup clone myproject myproject-backup
+
+# The cloned environment will have identical:
+# - Python version
+# - All dependencies (from pyproject.toml)
+# - Lock file (uv.lock)
+```
+
+### Template-based Project Creation
+
+Create new projects from template environments with modification support:
+
+```bash
+# Preview changes before creating
+uvup new myapp --template web-template --dry-run
+
+# Create a project from a template
+uvup new myapp --template web-template
+
+# Create with custom Python version
+uvup new myapp --template web-template --python 3.11
+
+# Create with package filtering
+uvup new myapp --template web-template --exclude pytest,black
+uvup new myapp --template web-template --include numpy,pandas,requests
+
+# Create in a custom directory
+uvup new myapp --template web-template --path ~/projects
+```
+
+### Template Synchronization
+
+Sync an existing project with a template environment:
+
+```bash
+# Preview changes before syncing
+uvup sync --template web-template --dry-run
+
+# Sync current project with template
+cd myproject
+uvup sync --template web-template
+
+# Sync with Python version override
+uvup sync --template web-template --python 3.11
+
+# Sync with package filtering
+uvup sync --template web-template --exclude dev-packages
+uvup sync --template web-template --include numpy,pandas
+```
+
+### Command Categories
+
+uvup provides four distinct command categories:
+
+1. **Create** - Create empty environments
+   ```bash
+   uvup create myenv --python 3.12
+   ```
+
+2. **Clone** - 1:1 exact copy (no modifications)
+   ```bash
+   uvup clone source-env target-env
+   ```
+
+3. **New** - Create projects from templates (with modifications)
+   ```bash
+   uvup new myproject --template base-template --exclude pytest
+   ```
+
+4. **Sync** - Update current project from template (with modifications)
+   ```bash
+   uvup sync --template base-template --python 3.11
+   ```
+
+For complete command reference with all options and examples, see [COMMANDS.md](docs/COMMANDS.md).
+
+## Documentation
+
+### Quick Help
+
+Use the built-in help system for command-specific usage:
+
+```bash
+# General help
+uvup --help
+
+# Command-specific help
+uvup new --help
+uvup sync --help
+uvup clone --help
+```
+
+### Complete Documentation
+
+- **[COMMANDS.md](docs/COMMANDS.md)** - Complete command reference with all options and examples
+- **[USE_CASES.md](docs/USE_CASES.md)** - Real-world usage scenarios and workflows
+- **[CHANGELOG.md](CHANGELOG.md)** - Version history and release notes
+
 ## Scope
 
-uvup focuses on **environment management only**. For package management, use uv directly:
+uvup focuses on **environment management and template-based workflows**. For package management, use uv directly:
 
 ```bash
 # Environment management with uvup
@@ -102,7 +207,10 @@ uvup create myproject
 uvup activate myproject
 
 # Package management with uv
-uv pip install numpy pandas
+uv add numpy pandas
+uv remove pandas
+uv lock
+uv sync
 ```
 
 ## IDE Integration
diff --git a/docs/COMMANDS.md b/docs/COMMANDS.md
new file mode 100644
index 0000000..942ac48
--- /dev/null
+++ b/docs/COMMANDS.md
@@ -0,0 +1,434 @@
+# Command Reference
+
+Complete reference for all uvup commands.
+
+## Table of Contents
+
+- [Environment Management](#environment-management)
+  - [create](#create)
+  - [list](#list)
+  - [remove](#remove)
+- [Environment Operations](#environment-operations)
+  - [clone](#clone)
+  - [new](#new)
+  - [sync](#sync)
+- [System](#system)
+  - [init](#init)
+  - [update](#update)
+
+## Environment Management
+
+### create
+
+Create a new empty virtual environment.
+
+**Usage:**
+```bash
+uvup create <name> [OPTIONS]
+```
+
+**Arguments:**
+- `<name>` - Name of the environment to create
+
+**Options:**
+- `-p, --python <version>` - Python version (default: 3.12)
+
+**Examples:**
+```bash
+# Create environment with default Python
+uvup create myproject
+
+# Create with specific Python version
+uvup create myproject --python 3.11
+uvup create --python 3.11 myproject
+```
+
+**Notes:**
+- Creates an empty pyproject.toml with minimal configuration
+- Initializes a virtual environment with uv
+- Environment is created in `~/.uvup/<name>/`
+
+---
+
+### list
+
+List all available environments.
+
+**Usage:**
+```bash
+uvup list
+```
+
+**Output:**
+- Lists all environments in `~/.uvup/`
+- Shows "No environments found." if empty
+
+**Examples:**
+```bash
+uvup list
+```
+
+---
+
+### remove
+
+Remove an existing environment.
+
+**Usage:**
+```bash
+uvup remove <name>
+```
+
+**Arguments:**
+- `<name>` - Name of the environment to remove
+
+**Examples:**
+```bash
+uvup remove myproject
+```
+
+**Notes:**
+- Permanently deletes the environment directory
+- Cannot be undone
+- Fails if environment doesn't exist
+- Only one environment can be removed at a time
+
+---
+
+## Environment Operations
+
+### clone
+
+Clone an existing environment to create an exact 1:1 copy.
+
+**Usage:**
+```bash
+uvup clone <source> <target>
+```
+
+**Arguments:**
+- `<source>` - Source environment name
+- `<target>` - Target environment name
+
+**Examples:**
+```bash
+# Create exact backup
+uvup clone myproject myproject-backup
+
+# Clone for testing
+uvup clone production testing
+```
+
+**What Gets Cloned:**
+- ✅ `pyproject.toml` - Project configuration
+- ✅ `hello.py` - Demo file (if exists)
+- ✅ `uv.lock` - Lock file (if exists)
+- ✅ Virtual environment - Fresh venv with same packages
+
+**What Doesn't Get Cloned:**
+- ❌ `.venv/` directory (recreated fresh)
+- ❌ Custom files (only standard files)
+
+**Notes:**
+- Pure 1:1 copy with **no modification options**
+- Use `new` if you need to modify during copy
+- Automatically syncs packages from lock file
+
+---
+
+### new
+
+Create a new project from a template environment with modification support.
+
+**Usage:**
+```bash
+uvup new <name> --template <template> [OPTIONS]
+```
+
+**Arguments:**
+- `<name>` - Project name
+- `--template <template>` - Template environment name
+
+**Options:**
+- `-p, --python <version>` - Override Python version
+- `--exclude <packages>` - Exclude packages (comma-separated)
+- `--include <packages>` - Include only these packages (comma-separated)
+- `--path <directory>` - Create in custom directory (default: current dir)
+- `--dry-run` - Preview changes without creating
+
+**Examples:**
+```bash
+# Basic project creation
+uvup new myapp --template web-template
+
+# Custom Python version
+uvup new myapp --template web-template --python 3.11
+
+# Exclude development tools
+uvup new myapp --template web-template --exclude pytest,black,mypy
+
+# Include only specific packages
+uvup new myapp --template web-template --include numpy,pandas,requests
+
+# Create in specific directory
+uvup new myapp --template web-template --path ~/projects
+
+# Preview without creating
+uvup new myapp --template web-template --exclude pytest --dry-run
+```
+
+**Modification Behavior:**
+
+1. **Project Name**: Automatically updated in pyproject.toml
+2. **Python Version**: Overridden if `--python` specified
+3. **Dependencies**: Filtered by `--exclude` or `--include`
+4. **Optional Dependencies**: Also filtered, empty groups removed
+
+**Filtering Rules:**
+
+- `--exclude`: Removes specified packages from both main and optional dependencies
+- `--include`: Keeps ONLY specified packages (removes all others)
+- Cannot use both `--exclude` and `--include` together
+- Package names are case-insensitive
+- Handles PEP 508 specifiers (e.g., `requests[http3]>=2.0`)
+
+**Dry-run Output:**
+```
+-- Dry Run Mode --
+
+Template: 'web-template' (Python 3.12)
+Project:  'myapp' (Python 3.11)
+Location: /Users/you/myapp
+
+Python version change:
+  3.12 → 3.11
+
+Filters applied:
+  Exclude: pytest, black
+
+Dependency changes:
+  Removed (2):
+    - pytest>=7.0.0
+    - black>=23.0.0
+  Kept (5):
+
+Optional dependencies:
+  [dev]: Removed (group is empty after filtering)
+  [viz]: No changes
+
+To create this project, run the same command without --dry-run
+```
+
+**Notes:**
+- Creates project in `<path>/<name>/` (default: `./<name>/`)
+- Fails if target directory already exists
+- Automatically runs `uv lock` and `uv sync`
+- Project is ready to use immediately
+
+---
+
+### sync
+
+Sync current project with a template environment.
+
+**Usage:**
+```bash
+uvup sync --template <template> [OPTIONS]
+```
+
+**Arguments:**
+- `--template <template>` - Template environment name
+
+**Options:**
+- `-p, --python <version>` - Override Python version
+- `--exclude <packages>` - Exclude packages (comma-separated)
+- `--include <packages>` - Include only these packages (comma-separated)
+- `--dry-run` - Preview changes without syncing
+
+**Examples:**
+```bash
+# Sync with template
+cd myproject
+uvup sync --template web-template
+
+# Sync with Python version change
+uvup sync --template web-template --python 3.11
+
+# Sync without dev dependencies
+uvup sync --template web-template --exclude pytest,black,mypy
+
+# Sync only core packages
+uvup sync --template web-template --include numpy,pandas,requests
+
+# Preview changes
+uvup sync --template web-template --dry-run
+```
+
+**Sync Behavior:**
+
+1. **Dependencies**: Replaced with template's dependencies (filtered)
+2. **Optional Dependencies**: Replaced with template's optional-dependencies (filtered)
+3. **Python Version**: Updated if `--python` specified
+4. **Project Name**: Preserved (NOT changed)
+
+**Safety Features:**
+
+- ✅ Automatic backup: `pyproject.toml.backup` created before changes
+- ✅ Rollback on error: Backup restored if `uv lock` or `uv sync` fails
+- ✅ Backup cleanup: Removed on successful completion
+
+**Dry-run Output:**
+```
+-- Dry Run Mode --
+
+Template: 'web-template' (Python 3.12)
+Current:  /Users/you/myproject (Python 3.12)
+
+Dependency changes:
+  Added (2):
+    + fastapi>=0.100.0
+    + uvicorn>=0.23.0
+  Removed (1):
+    - flask>=2.3.0
+  Kept (3):
+
+Optional dependencies:
+  [dev]: Modified (5 packages)
+  [viz]: No changes
+
+To sync this project, run the same command without --dry-run
+```
+
+**Notes:**
+- Must be run from project directory containing `pyproject.toml`
+- Fails if no `pyproject.toml` found
+- Changes take effect immediately (except in dry-run mode)
+- Backup file is left if user interrupts (Ctrl+C)
+
+---
+
+## System
+
+### init
+
+Initialize shell integration for uvup.
+
+**Usage:**
+```bash
+uvup init
+```
+
+**Supported Shells:**
+- Bash
+- Zsh
+- Fish
+- PowerShell
+
+**What It Does:**
+- Detects your current shell
+- Adds uvup initialization to shell config
+- Enables `uvup activate` and `uvup deactivate` commands
+
+**Examples:**
+```bash
+# Initialize for current shell
+uvup init
+```
+
+**Shell Config Files:**
+- Bash: `~/.bashrc`
+- Zsh: `~/.zshrc`
+- Fish: `~/.config/fish/config.fish`
+- PowerShell: `$PROFILE`
+
+**Notes:**
+- Run this once after installation
+- Restart shell or source config file to apply
+- Safe to run multiple times (idempotent)
+
+---
+
+### update
+
+Update uvup to the latest version.
+
+**Usage:**
+```bash
+uvup update [OPTIONS]
+```
+
+**Options:**
+- `-c, --check` - Only check for updates without installing
+
+**Examples:**
+```bash
+# Update to latest version
+uvup update
+
+# Check if update available
+uvup update --check
+```
+
+**Notes:**
+- Downloads latest release from GitHub
+- Replaces current binary in-place
+- Preserves all environments and configuration
+
+---
+
+## Shell-only Commands
+
+These commands are available only after running `uvup init`:
+
+### activate
+
+Activate a virtual environment.
+
+**Usage:**
+```bash
+uvup activate <name>
+```
+
+**Arguments:**
+- `<name>` - Environment name to activate
+
+**Examples:**
+```bash
+uvup activate myproject
+```
+
+### deactivate
+
+Deactivate the current virtual environment.
+
+**Usage:**
+```bash
+uvup deactivate
+```
+
+**Examples:**
+```bash
+uvup deactivate
+```
+
+---
+
+## Command Decision Tree
+
+**Need to create something?**
+- Empty environment → `create`
+- Exact copy → `clone`
+- New project from template → `new`
+
+**Need to update?**
+- Current project from template → `sync`
+- uvup itself → `update`
+
+**Need to manage?**
+- See all environments → `list`
+- Delete environment → `remove`
+
+**Need to use?**
+- Enable activation → `init`
+- Enter environment → `activate`
+- Exit environment → `deactivate`
diff --git a/docs/USE_CASES.md b/docs/USE_CASES.md
new file mode 100644
index 0000000..9735ee9
--- /dev/null
+++ b/docs/USE_CASES.md
@@ -0,0 +1,474 @@
+# Use Cases
+
+Real-world scenarios and workflows with uvup.
+
+## Table of Contents
+
+- [Getting Started](#getting-started)
+- [Development Workflows](#development-workflows)
+- [Team Collaboration](#team-collaboration)
+- [Project Management](#project-management)
+- [Advanced Patterns](#advanced-patterns)
+
+## Getting Started
+
+### First Time Setup
+
+```bash
+# 1. Install uvup
+curl -fsSL https://raw.githubusercontent.com/KercyDing/uvup/main/scripts/install.sh | sh
+
+# 2. Initialize shell integration
+uvup init
+
+# 3. Restart your shell or source config
+source ~/.bashrc  # or ~/.zshrc, etc.
+
+# 4. Create your first environment
+uvup create my-first-project --python 3.12
+
+# 5. Activate and use it
+uvup activate my-first-project
+uv add requests numpy
+python -c "import requests; print(requests.__version__)"
+uvup deactivate
+```
+
+### Quick Project Creation
+
+```bash
+# Create a simple data science project
+uvup create ds-project
+uvup activate ds-project
+uv add numpy pandas matplotlib jupyter
+jupyter notebook
+```
+
+## Development Workflows
+
+### Creating Template Environments
+
+Create reusable templates for different project types:
+
+```bash
+# 1. Create base web template
+uvup create web-template
+uvup activate web-template
+uv add fastapi uvicorn pydantic
+uv add --group dev pytest black mypy ruff
+uvup deactivate
+
+# 2. Create data science template
+uvup create ds-template
+uvup activate ds-template
+uv add numpy pandas matplotlib seaborn scikit-learn
+uv add --group dev jupyter ipykernel pytest
+uvup deactivate
+
+# 3. Create CLI tool template
+uvup create cli-template
+uvup activate cli-template
+uv add click rich typer
+uv add --group dev pytest pytest-cov
+uvup deactivate
+```
+
+### Starting New Projects from Templates
+
+```bash
+# Start a new web API project
+uvup new my-api --template web-template
+
+# Start without dev tools (for production containers)
+uvup new my-api --template web-template --exclude pytest,black,mypy,ruff
+
+# Start with only core dependencies
+uvup new minimal-api --template web-template --include fastapi,uvicorn,pydantic
+```
+
+### Syncing Existing Projects
+
+```bash
+# Update project with latest template changes
+cd my-existing-project
+uvup sync --template web-template --dry-run
+# Review changes...
+uvup sync --template web-template
+
+# Sync but keep dev tools separate
+uvup sync --template web-template --exclude pytest,black,mypy
+```
+
+## Team Collaboration
+
+### Sharing Environment Definitions
+
+**Scenario**: Team wants consistent development environments.
+
+```bash
+# Team lead creates template
+uvup create team-base-template --python 3.11
+uvup activate team-base-template
+uv add requests httpx pydantic sqlalchemy
+uv add --group dev pytest black mypy ruff pre-commit
+uv add --group docs sphinx sphinx-rtd-theme
+uvup deactivate
+
+# Team lead shares the pyproject.toml
+cp ~/.uvup/team-base-template/pyproject.toml ./templates/
+
+# Team members create from template
+uvup create team-base-template
+uvup activate team-base-template
+# Copy pyproject.toml to environment
+cp ./templates/pyproject.toml ~/.uvup/team-base-template/
+cd ~/.uvup/team-base-template
+uv lock
+uv sync
+uvup deactivate
+
+# Now everyone can create consistent projects
+uvup new my-feature --template team-base-template
+```
+
+### Onboarding New Developers
+
+```bash
+# New developer setup script
+#!/bin/bash
+
+# Install uvup
+curl -fsSL https://raw.githubusercontent.com/KercyDing/uvup/main/scripts/install.sh | sh
+uvup init
+
+# Create standard templates
+uvup create backend-template
+cp templates/backend.toml ~/.uvup/backend-template/pyproject.toml
+cd ~/.uvup/backend-template && uv sync && cd -
+
+uvup create frontend-template
+cp templates/frontend.toml ~/.uvup/frontend-template/pyproject.toml
+cd ~/.uvup/frontend-template && uv sync && cd -
+
+# Clone current project
+git clone https://github.com/company/project
+cd project
+uvup sync --template backend-template
+```
+
+## Project Management
+
+### Managing Multiple Projects
+
+```bash
+# List all projects
+uvup list
+
+# Create project-specific environments
+uvup new client-a-api --template web-template
+uvup new client-b-api --template web-template
+uvup new data-pipeline --template ds-template
+
+# Switch between projects
+cd ~/projects/client-a-api && uvup activate client-a-api
+# ... work on client A ...
+uvup deactivate
+
+cd ~/projects/client-b-api && uvup activate client-b-api
+# ... work on client B ...
+uvup deactivate
+```
+
+### Experimenting Safely
+
+```bash
+# Clone production environment for testing
+uvup clone production-env experiment-env
+
+# Activate and test new packages
+uvup activate experiment-env
+uv add experimental-package
+python -m pytest
+# ... experiment ...
+uvup deactivate
+
+# If successful, update template
+uvup sync --template production-template --dry-run
+# Review and apply
+uvup sync --template production-template
+
+# If failed, just remove experiment
+uvup remove experiment-env
+```
+
+### Upgrading Dependencies
+
+```bash
+# Create backup before upgrade
+uvup clone my-project my-project-backup
+
+# Upgrade in original
+uvup activate my-project
+uv add numpy@latest pandas@latest
+python -m pytest
+# ... verify everything works ...
+uvup deactivate
+
+# If successful, update template
+cd ~/.uvup/my-project-template
+uv add numpy@latest pandas@latest
+uv lock
+
+# If failed, restore from backup
+uvup remove my-project
+uvup clone my-project-backup my-project
+uvup remove my-project-backup
+```
+
+## Advanced Patterns
+
+### Multi-Stage Project Setup
+
+**Scenario**: Different dependency sets for dev/test/prod.
+
+```bash
+# Base template with core dependencies
+uvup create base-template
+uvup activate base-template
+uv add fastapi uvicorn pydantic sqlalchemy
+uvup deactivate
+
+# Development environment (full stack)
+uvup new my-project-dev --template base-template
+cd my-project-dev
+uv add --group dev pytest black mypy ruff ipython
+uv add --group dev pytest-cov pytest-asyncio
+
+# Testing environment (dev + test tools only)
+uvup new my-project-test --template base-template
+cd ../my-project-test
+uv add --group dev pytest pytest-cov pytest-asyncio
+
+# Production environment (minimal)
+uvup new my-project-prod --template base-template \
+  --exclude pytest,black,mypy,ruff,ipython
+```
+
+### Microservices Development
+
+**Scenario**: Multiple services with shared base, different extras.
+
+```bash
+# Create shared base template
+uvup create microservice-base
+uvup activate microservice-base
+uv add fastapi uvicorn pydantic httpx
+uv add --group dev pytest pytest-asyncio
+uvup deactivate
+
+# Create service-specific projects
+uvup new auth-service --template microservice-base
+cd auth-service
+uv add pyjwt passlib[bcrypt] python-multipart
+
+uvup new user-service --template microservice-base
+cd ../user-service
+uv add sqlalchemy asyncpg alembic
+
+uvup new notification-service --template microservice-base
+cd ../notification-service
+uv add aiosmtplib jinja2 celery
+```
+
+### Educational Environments
+
+**Scenario**: Teaching Python with consistent student environments.
+
+```bash
+# Instructor creates course template
+uvup create course-python-basics
+uvup activate course-python-basics
+uv add ipython jupyter notebook pytest
+uvup deactivate
+
+# Students clone for each module
+uvup new module-01-basics --template course-python-basics
+uvup new module-02-functions --template course-python-basics
+uvup new module-03-classes --template course-python-basics
+
+# Each module can have specific packages
+cd module-02-functions
+uv add hypothesis  # for property-based testing
+
+cd ../module-03-classes
+uv add attrs pydantic  # for class examples
+```
+
+### CI/CD Integration
+
+**Scenario**: Reproducible CI environments.
+
+```bash
+# Local development
+uvup create ci-template
+uvup activate ci-template
+uv add pytest pytest-cov black mypy ruff
+uvup deactivate
+
+# Export for CI (Dockerfile)
+cat > Dockerfile << 'DOCKERFILE'
+FROM python:3.12-slim
+
+# Install uv
+RUN pip install uv
+
+# Copy project
+COPY . /app
+WORKDIR /app
+
+# Install dependencies
+RUN uv sync
+
+# Run tests
+CMD ["uv", "run", "pytest"]
+DOCKERFILE
+
+# Or use template in CI script
+# .github/workflows/test.yml
+cat > .github/workflows/test.yml << 'YAML'
+name: Test
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+      - name: Install uvup
+        run: curl -fsSL https://raw.githubusercontent.com/KercyDing/uvup/main/scripts/install.sh | sh
+      - name: Create from template
+        run: |
+          uvup create ci-env --python 3.12
+          cp pyproject.toml ~/.uvup/ci-env/
+          cd ~/.uvup/ci-env && uv sync
+      - name: Run tests
+        run: cd ~/.uvup/ci-env && uv run pytest
+YAML
+```
+
+### Dependency Isolation Testing
+
+**Scenario**: Test with different dependency versions.
+
+```bash
+# Base template
+uvup create app-template
+uvup activate app-template
+uv add requests flask numpy
+uvup deactivate
+
+# Test with minimum versions
+uvup new app-min-versions --template app-template
+cd app-min-versions
+# Manually set minimum versions in pyproject.toml
+uv lock
+uv sync
+uv run pytest
+
+# Test with latest versions
+uvup new app-latest-versions --template app-template
+cd ../app-latest-versions
+uv add requests@latest flask@latest numpy@latest
+uv run pytest
+
+# Test without optional dependencies
+uvup new app-no-optional --template app-template \
+  --exclude dev-package-1,dev-package-2
+cd ../app-no-optional
+uv run pytest
+```
+
+## Tips and Best Practices
+
+### Template Naming Conventions
+
+```bash
+# Use descriptive names
+uvup create web-api-template      # Good
+uvup create template1             # Bad
+
+# Use versioning for templates
+uvup create web-api-v1-template
+uvup create web-api-v2-template
+
+# Use prefixes for categories
+uvup create ml-pytorch-template
+uvup create ml-tensorflow-template
+uvup create web-fastapi-template
+uvup create web-flask-template
+```
+
+### Regular Maintenance
+
+```bash
+#!/bin/bash
+# monthly-maintenance.sh
+
+# Update uvup itself
+uvup update
+
+# List all environments
+echo "Current environments:"
+uvup list
+
+# Update templates with latest packages
+for template in web-template ds-template cli-template; do
+  if uvup list | grep -q "$template"; then
+    echo "Updating $template..."
+    cd ~/.uvup/$template
+    uv add --upgrade $(uv pip list --format=freeze | cut -d= -f1)
+    uv lock
+  fi
+done
+```
+
+### Backup Strategy
+
+```bash
+#!/bin/bash
+# backup-environments.sh
+
+BACKUP_DIR=~/uvup-backups/$(date +%Y%m%d)
+mkdir -p "$BACKUP_DIR"
+
+# Backup all pyproject.toml files
+for env in ~/.uvup/*/; do
+  name=$(basename "$env")
+  cp "$env/pyproject.toml" "$BACKUP_DIR/$name.toml"
+done
+
+echo "Backed up to $BACKUP_DIR"
+```
+
+### Cleanup Unused Environments
+
+```bash
+#!/bin/bash
+# cleanup-old-environments.sh
+
+# List all environments with creation time
+for env in ~/.uvup/*/; do
+  name=$(basename "$env")
+  age=$(find "$env" -maxdepth 0 -mtime +30)
+  if [ -n "$age" ]; then
+    echo "Old environment: $name (> 30 days)"
+    read -p "Remove? (y/n) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+      uvup remove "$name"
+    fi
+  fi
+done
+```
diff --git a/src/cli.rs b/src/cli.rs
index 9cfa55b..25a7762 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -32,18 +32,76 @@ pub(crate) enum Commands {
         name: String,
     },
 
-    #[command(about = "Update uvup to the latest version")]
-    Update {
-        #[arg(short, long, help = "Only check for updates without installing")]
-        check: bool,
-    },
-
-    #[command(about = "Copy an environment to a new environment")]
-    Copy {
+    #[command(about = "Clone an environment (exact 1:1 copy)")]
+    Clone {
         #[arg(help = "Source environment name")]
         source: String,
 
-        #[arg(short, long, help = "Target environment name")]
+        #[arg(help = "Target environment name")]
+        target: String,
+    },
+
+    #[command(about = "Create a new project from a template")]
+    New {
+        #[arg(help = "Project name")]
         name: String,
+
+        #[arg(long, help = "Template environment name")]
+        template: String,
+
+        #[arg(short, long, help = "Python version (override template version)")]
+        python: Option<String>,
+
+        #[arg(
+            long,
+            value_delimiter = ',',
+            help = "Exclude packages (comma-separated)"
+        )]
+        exclude: Option<Vec<String>>,
+
+        #[arg(
+            long,
+            value_delimiter = ',',
+            help = "Include only these packages (comma-separated)"
+        )]
+        include: Option<Vec<String>>,
+
+        #[arg(long, help = "Directory to create project in (default: current dir)")]
+        path: Option<String>,
+
+        #[arg(long, help = "Preview changes without creating")]
+        dry_run: bool,
+    },
+
+    #[command(about = "Sync current project with a template")]
+    Sync {
+        #[arg(long, help = "Template environment name")]
+        template: String,
+
+        #[arg(short, long, help = "Python version (override current version)")]
+        python: Option<String>,
+
+        #[arg(
+            long,
+            value_delimiter = ',',
+            help = "Exclude packages (comma-separated)"
+        )]
+        exclude: Option<Vec<String>>,
+
+        #[arg(
+            long,
+            value_delimiter = ',',
+            help = "Include only these packages (comma-separated)"
+        )]
+        include: Option<Vec<String>>,
+
+        #[arg(long, help = "Preview changes without syncing")]
+        dry_run: bool,
+    },
+
+    #[command(about = "Update uvup to the latest version")]
+    Update {
+        #[arg(short, long, help = "Only check for updates without installing")]
+        check: bool,
     },
 }
diff --git a/src/commands/clone.rs b/src/commands/clone.rs
new file mode 100644
index 0000000..727756c
--- /dev/null
+++ b/src/commands/clone.rs
@@ -0,0 +1,94 @@
+// Allow println! in this module as it's used for user-facing output
+#![allow(clippy::print_stdout)]
+
+use crate::env::paths::{get_env_path, validate_env_name};
+use crate::error::{Result, UvupError};
+use crate::utils::print_success;
+use std::fs;
+use std::process::Command;
+
+/// Clone an environment (exact 1:1 copy without modifications)
+pub(crate) fn run(source: String, target: String) -> Result<()> {
+    // Validate names
+    validate_env_name(&source)?;
+    validate_env_name(&target)?;
+
+    // Check source exists
+    let source_path = get_env_path(&source)?;
+    if !source_path.exists() {
+        return Err(UvupError::EnvNotFound(source));
+    }
+
+    // Check target doesn't exist
+    let target_path = get_env_path(&target)?;
+    if target_path.exists() {
+        return Err(UvupError::EnvAlreadyExists(target));
+    }
+
+    println!("Cloning environment '{source}' to '{target}'...");
+
+    // Create target directory
+    fs::create_dir_all(&target_path)?;
+
+    // Copy pyproject.toml
+    let source_toml = source_path.join("pyproject.toml");
+    let target_toml = target_path.join("pyproject.toml");
+    fs::copy(&source_toml, &target_toml)
+        .map_err(|e| UvupError::PathError(format!("Failed to copy pyproject.toml: {e}")))?;
+
+    // Copy hello.py if exists
+    let source_hello = source_path.join("hello.py");
+    if source_hello.exists() {
+        let target_hello = target_path.join("hello.py");
+        fs::copy(&source_hello, &target_hello)
+            .map_err(|e| UvupError::PathError(format!("Failed to copy hello.py: {e}")))?;
+    }
+
+    // Copy uv.lock if exists
+    let source_lock = source_path.join("uv.lock");
+    if source_lock.exists() {
+        let target_lock = target_path.join("uv.lock");
+        fs::copy(&source_lock, &target_lock)
+            .map_err(|e| UvupError::PathError(format!("Failed to copy uv.lock: {e}")))?;
+    }
+
+    // Create venv
+    println!("Creating virtual environment...");
+    let venv_status = Command::new("uv")
+        .arg("venv")
+        .current_dir(&target_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv venv: {e}"))
+        })?;
+
+    if !venv_status.success() {
+        let _ = fs::remove_dir_all(&target_path);
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to create virtual environment".to_string(),
+        ));
+    }
+
+    // Sync packages (use existing lock file if available)
+    println!("Installing packages...");
+    let sync_status = Command::new("uv")
+        .arg("sync")
+        .current_dir(&target_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv sync: {e}"))
+        })?;
+
+    if !sync_status.success() {
+        let _ = fs::remove_dir_all(&target_path);
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to install packages".to_string(),
+        ));
+    }
+
+    print_success(&format!(
+        "Successfully cloned environment '{source}' to '{target}'"
+    ));
+
+    Ok(())
+}
diff --git a/src/commands/copy.rs b/src/commands/copy.rs
deleted file mode 100644
index 1ee55eb..0000000
--- a/src/commands/copy.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-// Allow println! in this module as it's used for user-facing output
-#![allow(clippy::print_stdout)]
-
-use crate::env::paths::{get_env_path, get_envs_dir, validate_env_name};
-use crate::error::{Result, UvupError};
-use crate::utils::print_success;
-use std::fs;
-use std::path::Path;
-use std::process::Command;
-
-pub(crate) fn run(source: String, target: String) -> Result<()> {
-    validate_env_name(&source)?;
-    validate_env_name(&target)?;
-
-    let source_path = get_env_path(&source)?;
-    if !source_path.exists() {
-        return Err(UvupError::EnvNotFound(source));
-    }
-
-    let target_path = get_env_path(&target)?;
-    if target_path.exists() {
-        return Err(UvupError::EnvAlreadyExists(target));
-    }
-
-    println!("Copying environment '{source}' to '{target}'...");
-
-    // Export packages from source environment
-    println!("Exporting packages from '{source}'...");
-    let requirements = export_packages(&source_path)?;
-
-    // Detect Python version from source environment
-    let python_version = get_python_version(&source_path)?;
-
-    // Create target environment
-    println!("Creating environment '{target}' with Python {python_version}...");
-    create_environment(&target, &python_version)?;
-
-    // Sync packages to target environment
-    if requirements.trim().is_empty() {
-        println!("Source environment has no packages installed");
-        print_success(&format!("Created empty environment '{target}'"));
-    } else {
-        println!("Installing packages...");
-        sync_packages(&target_path, &requirements)?;
-        print_success(&format!(
-            "Successfully copied environment '{source}' to '{target}'"
-        ));
-    }
-
-    Ok(())
-}
-
-/// Export packages from an environment using uv pip freeze
-fn export_packages(env_path: &Path) -> Result<String> {
-    let python_bin = if cfg!(windows) {
-        env_path.join("Scripts").join("python.exe")
-    } else {
-        env_path.join("bin").join("python")
-    };
-
-    let output = Command::new("uv")
-        .arg("pip")
-        .arg("freeze")
-        .arg("--python")
-        .arg(&python_bin)
-        .output()
-        .map_err(|e| {
-            UvupError::CommandExecutionFailed(format!("Failed to run uv pip freeze: {e}"))
-        })?;
-
-    if !output.status.success() {
-        return Err(UvupError::CommandExecutionFailed(
-            "Failed to export packages".to_string(),
-        ));
-    }
-
-    String::from_utf8(output.stdout).map_err(|e| {
-        UvupError::CommandExecutionFailed(format!("Invalid UTF-8 in package list: {e}"))
-    })
-}
-
-/// Get Python version from pyvenv.cfg
-fn get_python_version(env_path: &Path) -> Result<String> {
-    let cfg_path = env_path.join("pyvenv.cfg");
-    let cfg_content = fs::read_to_string(&cfg_path)
-        .map_err(|e| UvupError::PathError(format!("Failed to read pyvenv.cfg: {e}")))?;
-
-    // Parse version_info line (e.g., "version_info = 3.12.11")
-    for line in cfg_content.lines() {
-        if let Some(version) = line.strip_prefix("version_info = ") {
-            let parts: Vec<&str> = version.split('.').collect();
-            if parts.len() >= 2 {
-                return Ok(format!("{}.{}", parts[0], parts[1]));
-            }
-        }
-    }
-
-    // Fallback to default version
-    Ok("3.12".to_string())
-}
-
-/// Create a new environment using uv venv
-fn create_environment(name: &str, python_version: &str) -> Result<()> {
-    let env_path = get_env_path(name)?;
-    let envs_dir = get_envs_dir()?;
-    fs::create_dir_all(&envs_dir)?;
-
-    let status = Command::new("uv")
-        .arg("venv")
-        .arg(&env_path)
-        .arg("--python")
-        .arg(python_version)
-        .status()
-        .map_err(|e| UvupError::CommandExecutionFailed(format!("Failed to execute uv: {e}")))?;
-
-    if !status.success() {
-        return Err(UvupError::CommandExecutionFailed(format!(
-            "Failed to create environment '{name}'"
-        )));
-    }
-
-    Ok(())
-}
-
-/// Sync packages to target environment using uv pip sync
-fn sync_packages(env_path: &Path, requirements: &str) -> Result<()> {
-    // Create temporary requirements file
-    let temp_file = tempfile::NamedTempFile::new().map_err(|e| {
-        UvupError::CommandExecutionFailed(format!("Failed to create temp file: {e}"))
-    })?;
-
-    fs::write(&temp_file, requirements).map_err(|e| {
-        UvupError::CommandExecutionFailed(format!("Failed to write requirements: {e}"))
-    })?;
-
-    let python_bin = if cfg!(windows) {
-        env_path.join("Scripts").join("python.exe")
-    } else {
-        env_path.join("bin").join("python")
-    };
-
-    // Use uv pip sync for precise environment reproduction
-    let status = Command::new("uv")
-        .arg("pip")
-        .arg("sync")
-        .arg("--python")
-        .arg(&python_bin)
-        .arg(temp_file.path())
-        .status()
-        .map_err(|e| {
-            UvupError::CommandExecutionFailed(format!("Failed to execute uv pip sync: {e}"))
-        })?;
-
-    if !status.success() {
-        return Err(UvupError::CommandExecutionFailed(
-            "Failed to install packages".to_string(),
-        ));
-    }
-
-    Ok(())
-}
diff --git a/src/commands/create.rs b/src/commands/create.rs
index 475ee1d..9022e80 100644
--- a/src/commands/create.rs
+++ b/src/commands/create.rs
@@ -22,18 +22,44 @@ pub(crate) fn run(name: String, python_version: Option<&str>) -> Result<()> {
 
     let py_version = python_version.unwrap_or(DEFAULT_PYTHON_VERSION);
 
-    let status = Command::new("uv")
-        .arg("venv")
-        .arg(&env_path)
+    // Create project directory
+    fs::create_dir_all(&env_path)?;
+
+    // Initialize uv project
+    let init_status = Command::new("uv")
+        .arg("init")
+        .arg("--no-readme")
         .arg("--python")
         .arg(py_version)
+        .current_dir(&env_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv init: {e}"))
+        })?;
+
+    if !init_status.success() {
+        // Clean up on failure
+        let _ = fs::remove_dir_all(&env_path);
+        return Err(UvupError::CommandExecutionFailed(format!(
+            "Failed to initialize project for environment '{name}'"
+        )));
+    }
+
+    // Create virtual environment
+    let venv_status = Command::new("uv")
+        .arg("venv")
+        .current_dir(&env_path)
         .status()
-        .map_err(|e| UvupError::CommandExecutionFailed(format!("Failed to execute uv: {e}")))?;
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv venv: {e}"))
+        })?;
 
-    if status.success() {
+    if venv_status.success() {
         print_success(&format!("Environment '{name}' created successfully"));
         Ok(())
     } else {
+        // Clean up on failure
+        let _ = fs::remove_dir_all(&env_path);
         Err(UvupError::CommandExecutionFailed(format!(
             "Failed to create environment '{name}'"
         )))
diff --git a/src/commands/list.rs b/src/commands/list.rs
index ecbcc84..cf399b2 100644
--- a/src/commands/list.rs
+++ b/src/commands/list.rs
@@ -43,13 +43,16 @@ pub(crate) fn run() -> Result<()> {
 }
 
 fn is_valid_env(path: &std::path::Path) -> bool {
+    // Check for .venv subdirectory structure (new format)
+    let venv_path = path.join(".venv");
+
     #[cfg(target_os = "windows")]
     {
-        path.join("Scripts").join("Activate.ps1").exists()
+        venv_path.join("Scripts").join("Activate.ps1").exists()
     }
 
     #[cfg(not(target_os = "windows"))]
     {
-        path.join("bin").join("activate").exists()
+        venv_path.join("bin").join("activate").exists()
     }
 }
diff --git a/src/commands/mod.rs b/src/commands/mod.rs
index 03132d7..ba7b32a 100644
--- a/src/commands/mod.rs
+++ b/src/commands/mod.rs
@@ -1,6 +1,8 @@
-pub(crate) mod copy;
+pub(crate) mod clone;
 pub(crate) mod create;
 pub(crate) mod init;
 pub(crate) mod list;
+pub(crate) mod new;
 pub(crate) mod remove;
+pub(crate) mod sync;
 pub(crate) mod update;
diff --git a/src/commands/new.rs b/src/commands/new.rs
new file mode 100644
index 0000000..726a8d6
--- /dev/null
+++ b/src/commands/new.rs
@@ -0,0 +1,465 @@
+// Allow println! in this module as it's used for user-facing output
+#![allow(clippy::print_stdout)]
+
+use crate::env::paths::{get_env_path, validate_env_name};
+use crate::error::{Result, UvupError};
+use crate::utils::print_success;
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use toml_edit::{DocumentMut, Item, Value};
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn run(
+    name: &str,
+    template: String,
+    python: Option<&str>,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+    path: Option<&str>,
+    dry_run: bool,
+) -> Result<()> {
+    // Validate template name
+    validate_env_name(&template)?;
+
+    // Check template exists
+    let template_path = get_env_path(&template)?;
+    if !template_path.exists() {
+        return Err(UvupError::EnvNotFound(template));
+    }
+
+    // Determine project path
+    let project_path = if let Some(p) = path {
+        PathBuf::from(p).join(name)
+    } else {
+        env::current_dir()
+            .map_err(|e| UvupError::PathError(format!("Failed to get current directory: {e}")))?
+            .join(name)
+    };
+
+    // Check project doesn't exist
+    if project_path.exists() {
+        return Err(UvupError::PathError(format!(
+            "Directory '{}' already exists",
+            project_path.display()
+        )));
+    }
+
+    // Read and process template pyproject.toml
+    let template_doc = read_and_parse_toml(&template_path)?;
+    let mut project_doc = template_doc.clone();
+
+    // Apply filters
+    if exclude.is_some() || include.is_some() {
+        filter_dependencies(&mut project_doc, exclude, include)?;
+    }
+
+    // Get Python versions
+    let template_python = get_python_version_from_toml(&template_doc)?;
+    let project_python = if let Some(version) = python {
+        update_python_version(&mut project_doc, version)?;
+        version.to_string()
+    } else {
+        template_python.clone()
+    };
+
+    // Update project name in pyproject.toml
+    if let Some(project_table) = project_doc.get_mut("project") {
+        if let Some(name_item) = project_table.get_mut("name") {
+            *name_item = Item::Value(Value::from(name));
+        }
+    }
+
+    // Dry-run mode
+    if dry_run {
+        print_dry_run_preview(
+            &template,
+            name,
+            &project_path,
+            &template_doc,
+            &project_doc,
+            &template_python,
+            &project_python,
+            exclude,
+            include,
+        );
+        return Ok(());
+    }
+
+    // Create project
+    println!("Creating project '{name}' from template '{template}'...");
+
+    fs::create_dir_all(&project_path)?;
+
+    // Write pyproject.toml
+    fs::write(project_path.join("pyproject.toml"), project_doc.to_string())
+        .map_err(|e| UvupError::PathError(format!("Failed to write pyproject.toml: {e}")))?;
+
+    // Create venv
+    println!("Creating virtual environment with Python {project_python}...");
+    let venv_status = Command::new("uv")
+        .arg("venv")
+        .current_dir(&project_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv venv: {e}"))
+        })?;
+
+    if !venv_status.success() {
+        let _ = fs::remove_dir_all(&project_path);
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to create virtual environment".to_string(),
+        ));
+    }
+
+    // Lock and sync
+    println!("Installing packages...");
+    sync_environment(&project_path)?;
+
+    print_success(&format!(
+        "Successfully created project '{name}' from template '{template}'"
+    ));
+    println!("Project location: {}", project_path.display());
+
+    Ok(())
+}
+
+/// Read and parse pyproject.toml
+fn read_and_parse_toml(path: &Path) -> Result<DocumentMut> {
+    let toml_path = path.join("pyproject.toml");
+    let toml_content = fs::read_to_string(&toml_path)
+        .map_err(|e| UvupError::PathError(format!("Failed to read pyproject.toml: {e}")))?;
+
+    toml_content.parse::<DocumentMut>().map_err(|e| {
+        UvupError::CommandExecutionFailed(format!("Failed to parse pyproject.toml: {e}"))
+    })
+}
+
+/// Lock and sync packages
+fn sync_environment(project_path: &Path) -> Result<()> {
+    println!("  Resolving and locking dependencies...");
+    let lock_status = Command::new("uv")
+        .arg("lock")
+        .current_dir(project_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv lock: {e}"))
+        })?;
+
+    if !lock_status.success() {
+        let _ = fs::remove_dir_all(project_path);
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to resolve and lock dependencies (possible version conflicts)".to_string(),
+        ));
+    }
+
+    println!("  Installing locked packages...");
+    let sync_status = Command::new("uv")
+        .arg("sync")
+        .current_dir(project_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv sync: {e}"))
+        })?;
+
+    if !sync_status.success() {
+        let _ = fs::remove_dir_all(project_path);
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to install locked packages (possible network or permission issues)".to_string(),
+        ));
+    }
+
+    Ok(())
+}
+
+/// Filter dependencies
+fn filter_dependencies(
+    doc: &mut DocumentMut,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+) -> Result<()> {
+    // Filter main dependencies
+    if let Some(dependencies) = doc
+        .get_mut("project")
+        .and_then(|p| p.get_mut("dependencies"))
+    {
+        let deps_array = dependencies.as_array_mut().ok_or_else(|| {
+            UvupError::CommandExecutionFailed("Invalid dependencies format".to_string())
+        })?;
+
+        let filtered = filter_dependency_array(deps_array, exclude, include);
+        *deps_array = toml_edit::Array::from_iter(filtered);
+    }
+
+    // Filter optional-dependencies
+    if let Some(project) = doc.get_mut("project") {
+        if let Some(optional_deps) = project.get_mut("optional-dependencies") {
+            if let Some(optional_table) = optional_deps.as_table_mut() {
+                let mut empty_groups = Vec::new();
+
+                for (group_name, group_deps) in optional_table.iter_mut() {
+                    if let Some(deps_array) = group_deps.as_array_mut() {
+                        let filtered = filter_dependency_array(deps_array, exclude, include);
+
+                        if filtered.is_empty() {
+                            println!(
+                                "  Note: Optional group '{group_name}' is now empty after filtering"
+                            );
+                            empty_groups.push(group_name.to_string());
+                        } else {
+                            *deps_array = toml_edit::Array::from_iter(filtered);
+                        }
+                    }
+                }
+
+                for group in empty_groups {
+                    optional_table.remove(&group);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Filter a single dependency array
+fn filter_dependency_array(
+    deps_array: &toml_edit::Array,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+) -> Vec<toml_edit::Value> {
+    let mut filtered_deps = Vec::new();
+
+    for dep in deps_array {
+        if let Some(dep_str) = dep.as_str() {
+            let package_name = extract_package_name(dep_str);
+
+            if let Some(include_list) = include {
+                let included = include_list
+                    .iter()
+                    .any(|inc| package_name == inc.to_lowercase());
+                if !included {
+                    continue;
+                }
+            }
+
+            if let Some(exclude_list) = exclude {
+                let excluded = exclude_list
+                    .iter()
+                    .any(|exc| package_name == exc.to_lowercase());
+                if excluded {
+                    println!("  Excluding: {package_name}");
+                    continue;
+                }
+            }
+
+            filtered_deps.push(dep.clone());
+        }
+    }
+
+    filtered_deps
+}
+
+/// Extract package name from dependency string
+fn extract_package_name(dep_str: &str) -> String {
+    let end_pos = dep_str
+        .find(['=', '>', '<', '~', '!', '['])
+        .unwrap_or(dep_str.len());
+    dep_str[..end_pos].trim().to_lowercase()
+}
+
+/// Get Python version from pyproject.toml
+fn get_python_version_from_toml(doc: &DocumentMut) -> Result<String> {
+    let version_str = doc
+        .get("project")
+        .and_then(|p| p.get("requires-python"))
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| {
+            UvupError::CommandExecutionFailed(
+                "No requires-python found in pyproject.toml".to_string(),
+            )
+        })?;
+
+    let version = version_str
+        .trim_start_matches(|c: char| !c.is_ascii_digit())
+        .split('.')
+        .take(2)
+        .collect::<Vec<_>>()
+        .join(".");
+
+    Ok(version)
+}
+
+/// Update Python version in pyproject.toml
+fn update_python_version(doc: &mut DocumentMut, version: &str) -> Result<()> {
+    let requires_python = doc
+        .get_mut("project")
+        .and_then(|p| p.get_mut("requires-python"))
+        .ok_or_else(|| {
+            UvupError::CommandExecutionFailed(
+                "No requires-python found in pyproject.toml".to_string(),
+            )
+        })?;
+
+    *requires_python = Item::Value(Value::from(format!(">={version}")));
+    Ok(())
+}
+
+/// Print dry-run preview
+#[allow(clippy::too_many_arguments)]
+fn print_dry_run_preview(
+    template: &str,
+    name: &str,
+    project_path: &Path,
+    template_doc: &DocumentMut,
+    project_doc: &DocumentMut,
+    template_python: &str,
+    project_python: &str,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+) {
+    println!("-- Dry Run Mode --");
+    println!();
+    println!("Template: '{template}' (Python {template_python})");
+    println!("Project:  '{name}' (Python {project_python})");
+    println!("Location: {}", project_path.display());
+    println!();
+
+    if template_python != project_python {
+        println!("Python version change:");
+        println!("  {template_python} → {project_python}");
+        println!();
+    }
+
+    if exclude.is_some() || include.is_some() {
+        println!("Filters applied:");
+        if let Some(exc) = exclude {
+            println!("  Exclude: {}", exc.join(", "));
+        }
+        if let Some(inc) = include {
+            println!("  Include: {}", inc.join(", "));
+        }
+        println!();
+    }
+
+    println!("Dependency changes:");
+    compare_dependencies(template_doc, project_doc);
+    println!();
+
+    compare_optional_dependencies(template_doc, project_doc);
+
+    println!("To create this project, run the same command without --dry-run");
+}
+
+/// Compare dependencies
+fn compare_dependencies(template_doc: &DocumentMut, project_doc: &DocumentMut) {
+    let template_deps = extract_dependencies(template_doc);
+    let project_deps = extract_dependencies(project_doc);
+
+    let mut removed = Vec::new();
+    let mut kept = Vec::new();
+
+    for dep in &template_deps {
+        if project_deps.contains(dep) {
+            kept.push(dep);
+        } else {
+            removed.push(dep);
+        }
+    }
+
+    if removed.is_empty() {
+        println!("  No changes to main dependencies");
+    } else {
+        if !removed.is_empty() {
+            println!("  Removed ({}):", removed.len());
+            for dep in &removed {
+                println!("    - {dep}");
+            }
+        }
+        if !kept.is_empty() {
+            println!("  Kept ({}):", kept.len());
+        }
+    }
+}
+
+/// Compare optional-dependencies
+fn compare_optional_dependencies(template_doc: &DocumentMut, project_doc: &DocumentMut) {
+    let template_optional = extract_optional_dependencies(template_doc);
+    let project_optional = extract_optional_dependencies(project_doc);
+
+    if template_optional.is_empty() && project_optional.is_empty() {
+        return;
+    }
+
+    println!("Optional dependencies:");
+
+    let mut all_groups: std::collections::HashSet<String> =
+        template_optional.keys().cloned().collect();
+    all_groups.extend(project_optional.keys().cloned());
+
+    let mut groups: Vec<_> = all_groups.into_iter().collect();
+    groups.sort();
+
+    for group in groups {
+        let template_deps = template_optional.get(&group);
+        let project_deps = project_optional.get(&group);
+
+        match (template_deps, project_deps) {
+            (Some(src), Some(tgt)) if src == tgt => {
+                println!("  [{group}]: No changes");
+            }
+            (Some(_), Some(tgt)) => {
+                println!("  [{group}]: Modified ({} packages)", tgt.len());
+            }
+            (Some(_), None) => {
+                println!("  [{group}]: Removed (group is empty after filtering)");
+            }
+            (None, Some(tgt)) => {
+                println!("  [{group}]: Added ({} packages)", tgt.len());
+            }
+            (None, None) => unreachable!(),
+        }
+    }
+    println!();
+}
+
+/// Extract dependencies
+fn extract_dependencies(doc: &DocumentMut) -> Vec<String> {
+    doc.get("project")
+        .and_then(|p| p.get("dependencies"))
+        .and_then(|d| d.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str())
+                .map(String::from)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Extract optional-dependencies
+fn extract_optional_dependencies(
+    doc: &DocumentMut,
+) -> std::collections::HashMap<String, Vec<String>> {
+    let mut result = std::collections::HashMap::new();
+
+    if let Some(project) = doc.get("project") {
+        if let Some(optional) = project.get("optional-dependencies") {
+            if let Some(table) = optional.as_table() {
+                for (key, value) in table {
+                    if let Some(arr) = value.as_array() {
+                        let deps: Vec<String> = arr
+                            .iter()
+                            .filter_map(|v| v.as_str())
+                            .map(String::from)
+                            .collect();
+                        result.insert(key.to_string(), deps);
+                    }
+                }
+            }
+        }
+    }
+
+    result
+}
diff --git a/src/commands/sync.rs b/src/commands/sync.rs
new file mode 100644
index 0000000..b7cbbc5
--- /dev/null
+++ b/src/commands/sync.rs
@@ -0,0 +1,468 @@
+// Allow println! in this module as it's used for user-facing output
+#![allow(clippy::print_stdout)]
+
+use crate::env::paths::get_env_path;
+use crate::error::{Result, UvupError};
+use crate::utils::print_success;
+use std::env;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use toml_edit::{DocumentMut, Item, Value};
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn run(
+    template: String,
+    python: Option<&str>,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+    dry_run: bool,
+) -> Result<()> {
+    // Get current directory
+    let current_dir = env::current_dir()
+        .map_err(|e| UvupError::PathError(format!("Failed to get current directory: {e}")))?;
+
+    // Check pyproject.toml exists in current directory
+    let current_toml_path = current_dir.join("pyproject.toml");
+    if !current_toml_path.exists() {
+        return Err(UvupError::PathError(
+            "No pyproject.toml found in current directory".to_string(),
+        ));
+    }
+
+    // Check template exists
+    let template_path = get_env_path(&template)?;
+    if !template_path.exists() {
+        return Err(UvupError::EnvNotFound(template));
+    }
+
+    // Read current and template pyproject.toml
+    let current_doc = read_and_parse_toml(&current_toml_path)?;
+    let template_doc = read_and_parse_toml(&template_path.join("pyproject.toml"))?;
+
+    // Process template
+    let mut synced_doc = current_doc.clone();
+
+    // Sync dependencies from template
+    sync_dependencies(&mut synced_doc, &template_doc, exclude, include);
+
+    // Get Python versions
+    let current_python = get_python_version_from_toml(&current_doc)?;
+    let template_python = get_python_version_from_toml(&template_doc)?;
+    let synced_python = if let Some(version) = python {
+        update_python_version(&mut synced_doc, version)?;
+        version.to_string()
+    } else {
+        current_python.clone()
+    };
+
+    // Dry-run mode
+    if dry_run {
+        print_dry_run_preview(
+            &template,
+            &current_dir,
+            &current_doc,
+            &synced_doc,
+            &current_python,
+            &template_python,
+            &synced_python,
+            exclude,
+            include,
+        );
+        return Ok(());
+    }
+
+    // Sync project
+    println!("Syncing project with template '{template}'...");
+
+    // Backup current pyproject.toml
+    let backup_path = current_dir.join("pyproject.toml.backup");
+    fs::copy(&current_toml_path, &backup_path)
+        .map_err(|e| UvupError::PathError(format!("Failed to backup pyproject.toml: {e}")))?;
+
+    // Write updated pyproject.toml
+    fs::write(&current_toml_path, synced_doc.to_string())
+        .map_err(|e| UvupError::PathError(format!("Failed to write pyproject.toml: {e}")))?;
+
+    // Lock and sync
+    println!("Installing packages...");
+    if let Err(e) = sync_environment(&current_dir) {
+        // Restore backup on error
+        let _ = fs::copy(&backup_path, &current_toml_path);
+        let _ = fs::remove_file(&backup_path);
+        return Err(e);
+    }
+
+    // Remove backup on success
+    let _ = fs::remove_file(&backup_path);
+
+    print_success(&format!(
+        "Successfully synced project with template '{template}'"
+    ));
+
+    Ok(())
+}
+
+/// Read and parse pyproject.toml
+fn read_and_parse_toml(path: &Path) -> Result<DocumentMut> {
+    let toml_content = fs::read_to_string(path)
+        .map_err(|e| UvupError::PathError(format!("Failed to read pyproject.toml: {e}")))?;
+
+    toml_content.parse::<DocumentMut>().map_err(|e| {
+        UvupError::CommandExecutionFailed(format!("Failed to parse pyproject.toml: {e}"))
+    })
+}
+
+/// Lock and sync packages
+fn sync_environment(project_path: &Path) -> Result<()> {
+    println!("  Resolving and locking dependencies...");
+    let lock_status = Command::new("uv")
+        .arg("lock")
+        .current_dir(project_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv lock: {e}"))
+        })?;
+
+    if !lock_status.success() {
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to resolve and lock dependencies (possible version conflicts)".to_string(),
+        ));
+    }
+
+    println!("  Installing locked packages...");
+    let sync_status = Command::new("uv")
+        .arg("sync")
+        .current_dir(project_path)
+        .status()
+        .map_err(|e| {
+            UvupError::CommandExecutionFailed(format!("Failed to execute uv sync: {e}"))
+        })?;
+
+    if !sync_status.success() {
+        return Err(UvupError::CommandExecutionFailed(
+            "Failed to install locked packages (possible network or permission issues)".to_string(),
+        ));
+    }
+
+    Ok(())
+}
+
+/// Sync dependencies from template to current project
+fn sync_dependencies(
+    target_doc: &mut DocumentMut,
+    template_doc: &DocumentMut,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+) {
+    // Get template dependencies
+    if let Some(template_deps) = template_doc
+        .get("project")
+        .and_then(|p| p.get("dependencies"))
+        .and_then(|d| d.as_array())
+    {
+        let filtered = filter_dependency_array(template_deps, exclude, include);
+
+        // Update target dependencies
+        if let Some(target_project) = target_doc.get_mut("project") {
+            target_project["dependencies"] =
+                Item::Value(Value::Array(toml_edit::Array::from_iter(filtered)));
+        }
+    }
+
+    // Sync optional-dependencies
+    if let Some(template_optional) = template_doc
+        .get("project")
+        .and_then(|p| p.get("optional-dependencies"))
+        .and_then(|o| o.as_table())
+    {
+        let mut synced_optional = toml_edit::Table::new();
+
+        for (group_name, group_deps) in template_optional {
+            if let Some(deps_array) = group_deps.as_array() {
+                let filtered = filter_dependency_array(deps_array, exclude, include);
+
+                if filtered.is_empty() {
+                    println!(
+                        "  Note: Optional group '{group_name}' is empty after filtering, skipping"
+                    );
+                } else {
+                    synced_optional.insert(
+                        group_name,
+                        Item::Value(Value::Array(toml_edit::Array::from_iter(filtered))),
+                    );
+                }
+            }
+        }
+
+        // Update target optional-dependencies
+        if let Some(target_project) = target_doc.get_mut("project") {
+            if synced_optional.is_empty() {
+                target_project
+                    .as_table_mut()
+                    .map(|t| t.remove("optional-dependencies"));
+            } else {
+                target_project["optional-dependencies"] = Item::Table(synced_optional);
+            }
+        }
+    }
+}
+
+/// Filter a single dependency array
+fn filter_dependency_array(
+    deps_array: &toml_edit::Array,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+) -> Vec<toml_edit::Value> {
+    let mut filtered_deps = Vec::new();
+
+    for dep in deps_array {
+        if let Some(dep_str) = dep.as_str() {
+            let package_name = extract_package_name(dep_str);
+
+            if let Some(include_list) = include {
+                let included = include_list
+                    .iter()
+                    .any(|inc| package_name == inc.to_lowercase());
+                if !included {
+                    continue;
+                }
+            }
+
+            if let Some(exclude_list) = exclude {
+                let excluded = exclude_list
+                    .iter()
+                    .any(|exc| package_name == exc.to_lowercase());
+                if excluded {
+                    println!("  Excluding: {package_name}");
+                    continue;
+                }
+            }
+
+            filtered_deps.push(dep.clone());
+        }
+    }
+
+    filtered_deps
+}
+
+/// Extract package name from dependency string
+fn extract_package_name(dep_str: &str) -> String {
+    let end_pos = dep_str
+        .find(['=', '>', '<', '~', '!', '['])
+        .unwrap_or(dep_str.len());
+    dep_str[..end_pos].trim().to_lowercase()
+}
+
+/// Get Python version from pyproject.toml
+fn get_python_version_from_toml(doc: &DocumentMut) -> Result<String> {
+    let version_str = doc
+        .get("project")
+        .and_then(|p| p.get("requires-python"))
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| {
+            UvupError::CommandExecutionFailed(
+                "No requires-python found in pyproject.toml".to_string(),
+            )
+        })?;
+
+    let version = version_str
+        .trim_start_matches(|c: char| !c.is_ascii_digit())
+        .split('.')
+        .take(2)
+        .collect::<Vec<_>>()
+        .join(".");
+
+    Ok(version)
+}
+
+/// Update Python version in pyproject.toml
+fn update_python_version(doc: &mut DocumentMut, version: &str) -> Result<()> {
+    let requires_python = doc
+        .get_mut("project")
+        .and_then(|p| p.get_mut("requires-python"))
+        .ok_or_else(|| {
+            UvupError::CommandExecutionFailed(
+                "No requires-python found in pyproject.toml".to_string(),
+            )
+        })?;
+
+    *requires_python = Item::Value(Value::from(format!(">={version}")));
+    Ok(())
+}
+
+/// Print dry-run preview
+#[allow(clippy::too_many_arguments)]
+fn print_dry_run_preview(
+    template: &str,
+    current_dir: &Path,
+    current_doc: &DocumentMut,
+    synced_doc: &DocumentMut,
+    current_python: &str,
+    template_python: &str,
+    synced_python: &str,
+    exclude: Option<&[String]>,
+    include: Option<&[String]>,
+) {
+    println!("-- Dry Run Mode --");
+    println!();
+    println!("Template: '{template}' (Python {template_python})");
+    println!(
+        "Current:  {} (Python {current_python})",
+        current_dir.display()
+    );
+    if current_python != synced_python {
+        println!("Synced:   Python {synced_python}");
+    }
+    println!();
+
+    if current_python != synced_python {
+        println!("Python version change:");
+        println!("  {current_python} → {synced_python}");
+        println!();
+    }
+
+    if exclude.is_some() || include.is_some() {
+        println!("Filters applied:");
+        if let Some(exc) = exclude {
+            println!("  Exclude: {}", exc.join(", "));
+        }
+        if let Some(inc) = include {
+            println!("  Include: {}", inc.join(", "));
+        }
+        println!();
+    }
+
+    println!("Dependency changes:");
+    compare_dependencies(current_doc, synced_doc);
+    println!();
+
+    compare_optional_dependencies(current_doc, synced_doc);
+
+    println!("To sync this project, run the same command without --dry-run");
+}
+
+/// Compare dependencies
+fn compare_dependencies(current_doc: &DocumentMut, synced_doc: &DocumentMut) {
+    let current_deps = extract_dependencies(current_doc);
+    let synced_deps = extract_dependencies(synced_doc);
+
+    let mut added = Vec::new();
+    let mut removed = Vec::new();
+    let mut kept = Vec::new();
+
+    for dep in &synced_deps {
+        if current_deps.contains(dep) {
+            kept.push(dep);
+        } else {
+            added.push(dep);
+        }
+    }
+
+    for dep in &current_deps {
+        if !synced_deps.contains(dep) {
+            removed.push(dep);
+        }
+    }
+
+    if added.is_empty() && removed.is_empty() {
+        println!("  No changes to main dependencies");
+    } else {
+        if !added.is_empty() {
+            println!("  Added ({}):", added.len());
+            for dep in &added {
+                println!("    + {dep}");
+            }
+        }
+        if !removed.is_empty() {
+            println!("  Removed ({}):", removed.len());
+            for dep in &removed {
+                println!("    - {dep}");
+            }
+        }
+        if !kept.is_empty() {
+            println!("  Kept ({}):", kept.len());
+        }
+    }
+}
+
+/// Compare optional-dependencies
+fn compare_optional_dependencies(current_doc: &DocumentMut, synced_doc: &DocumentMut) {
+    let current_optional = extract_optional_dependencies(current_doc);
+    let synced_optional = extract_optional_dependencies(synced_doc);
+
+    if current_optional.is_empty() && synced_optional.is_empty() {
+        return;
+    }
+
+    println!("Optional dependencies:");
+
+    let mut all_groups: std::collections::HashSet<String> =
+        current_optional.keys().cloned().collect();
+    all_groups.extend(synced_optional.keys().cloned());
+
+    let mut groups: Vec<_> = all_groups.into_iter().collect();
+    groups.sort();
+
+    for group in groups {
+        let current_deps = current_optional.get(&group);
+        let synced_deps = synced_optional.get(&group);
+
+        match (current_deps, synced_deps) {
+            (Some(cur), Some(syn)) if cur == syn => {
+                println!("  [{group}]: No changes");
+            }
+            (Some(_), Some(syn)) => {
+                println!("  [{group}]: Modified ({} packages)", syn.len());
+            }
+            (Some(_), None) => {
+                println!("  [{group}]: Removed");
+            }
+            (None, Some(syn)) => {
+                println!("  [{group}]: Added ({} packages)", syn.len());
+            }
+            (None, None) => unreachable!(),
+        }
+    }
+    println!();
+}
+
+/// Extract dependencies
+fn extract_dependencies(doc: &DocumentMut) -> Vec<String> {
+    doc.get("project")
+        .and_then(|p| p.get("dependencies"))
+        .and_then(|d| d.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str())
+                .map(String::from)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Extract optional-dependencies
+fn extract_optional_dependencies(
+    doc: &DocumentMut,
+) -> std::collections::HashMap<String, Vec<String>> {
+    let mut result = std::collections::HashMap::new();
+
+    if let Some(project) = doc.get("project") {
+        if let Some(optional) = project.get("optional-dependencies") {
+            if let Some(table) = optional.as_table() {
+                for (key, value) in table {
+                    if let Some(arr) = value.as_array() {
+                        let deps: Vec<String> = arr
+                            .iter()
+                            .filter_map(|v| v.as_str())
+                            .map(String::from)
+                            .collect();
+                        result.insert(key.to_string(), deps);
+                    }
+                }
+            }
+        }
+    }
+
+    result
+}
diff --git a/src/env/paths.rs b/src/env/paths.rs
index 94ffb1b..74cdf6e 100644
--- a/src/env/paths.rs
+++ b/src/env/paths.rs
@@ -10,6 +10,7 @@ pub(crate) fn get_envs_dir() -> Result<PathBuf> {
     Ok(get_home_dir()?.join(".uvup"))
 }
 
+/// Get the project directory path for an environment (contains pyproject.toml)
 pub(crate) fn get_env_path(name: &str) -> Result<PathBuf> {
     validate_env_name(name)?;
     Ok(get_envs_dir()?.join(name))
diff --git a/src/main.rs b/src/main.rs
index 50421f0..862fc79 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -27,8 +27,38 @@ fn run() -> Result<()> {
         }
         Commands::List => commands::list::run()?,
         Commands::Remove { name } => commands::remove::run(name)?,
+        Commands::Clone { source, target } => commands::clone::run(source, target)?,
+        Commands::New {
+            name,
+            template,
+            python,
+            exclude,
+            include,
+            path,
+            dry_run,
+        } => commands::new::run(
+            &name,
+            template,
+            python.as_deref(),
+            exclude.as_deref(),
+            include.as_deref(),
+            path.as_deref(),
+            dry_run,
+        )?,
+        Commands::Sync {
+            template,
+            python,
+            exclude,
+            include,
+            dry_run,
+        } => commands::sync::run(
+            template,
+            python.as_deref(),
+            exclude.as_deref(),
+            include.as_deref(),
+            dry_run,
+        )?,
         Commands::Update { check } => commands::update::run(check)?,
-        Commands::Copy { source, name } => commands::copy::run(source, name)?,
     }
 
     Ok(())
diff --git a/src/shell/bash.rs b/src/shell/bash.rs
index 22d5595..777c02b 100644
--- a/src/shell/bash.rs
+++ b/src/shell/bash.rs
@@ -7,7 +7,7 @@ uvup() {
             return 1
         fi
 
-        local env_path="$HOME/.uvup/$2"
+        local env_path="$HOME/.uvup/$2/.venv"
         local activate_script="$env_path/bin/activate"
 
         if [ ! -f "$activate_script" ]; then
diff --git a/src/shell/fish.rs b/src/shell/fish.rs
index 204f985..00b7890 100644
--- a/src/shell/fish.rs
+++ b/src/shell/fish.rs
@@ -7,7 +7,7 @@ function uvup
             return 1
         end
 
-        set -l env_path "$HOME/.uvup/$argv[2]"
+        set -l env_path "$HOME/.uvup/$argv[2]/.venv"
         set -l activate_script "$env_path/bin/activate.fish"
 
         if not test -f "$activate_script"
diff --git a/src/shell/powershell.rs b/src/shell/powershell.rs
index add5ef4..f437266 100644
--- a/src/shell/powershell.rs
+++ b/src/shell/powershell.rs
@@ -9,7 +9,7 @@ function uvup {
             return
         }
 
-        $envPath = "$env:USERPROFILE\.uvup\$($Arguments[1])"
+        $envPath = "$env:USERPROFILE\.uvup\$($Arguments[1])\.venv"
         $activateScript = "$envPath\Scripts\Activate.ps1"
 
         if (-not (Test-Path $activateScript)) {