diff --git a/docs/LAZY_LOADING_CHARTS.md b/docs/LAZY_LOADING_CHARTS.md
new file mode 100644
index 0000000..d25acb3
--- /dev/null
+++ b/docs/LAZY_LOADING_CHARTS.md
@@ -0,0 +1,238 @@
+# Lazy-Loaded Chart Libraries
+
+This project implements lazy-loading for heavy chart libraries (Recharts, D3, Three.js, ReactFlow) to reduce the initial bundle size and improve page load performance.
+
+## Overview
+
+Instead of importing these libraries directly, which would include them in the main bundle, we dynamically import them only when needed. This can reduce the initial bundle size by hundreds of kilobytes.
+
+## Benefits
+
+- **Smaller Initial Bundle**: Chart libraries are only loaded when components that use them are rendered
+- **Faster Initial Load**: Users see the page faster, with charts loading in progressively
+- **Better Caching**: Libraries are cached separately and only re-downloaded when they change
+- **Automatic Retry**: Built-in retry logic handles temporary network failures
+- **Preloading Support**: Libraries can be preloaded on hover or route change
+
+## Usage
+
+### Using Hooks
+
+The recommended way to use lazy-loaded libraries is through the provided hooks:
+
+```typescript
+import { useRecharts, useD3, useThree, useReactFlow } from '@/hooks'
+
+function MyChartComponent() {
+  const { library: recharts, loading, error } = useRecharts()
+
+  if (loading) {
+    return <Skeleton className="h-[300px]" />
+  }
+
+  if (error) {
+    return <Alert>Failed to load chart library</Alert>
+  }
+
+  if (!recharts) {
+    return null
+  }
+
+  const { LineChart, Line, XAxis, YAxis } = recharts
+
+  return (
+    <LineChart data={data}>
+      <XAxis />
+      <YAxis />
+      <Line dataKey="value" />
+    </LineChart>
+  )
+}
+```
+
+### Using Pre-built Components
+
+For common use cases, we provide pre-built lazy-loaded chart components:
+
+```typescript
+import { LazyLineChart, LazyBarChart, LazyD3BarChart } from '@/components/molecules'
+
+function Dashboard() {
+  const data = [
+    { month: 'Jan', value: 100 },
+    { month: 'Feb', value: 150 },
+    { month: 'Mar', value: 200 },
+  ]
+
+  return (
+    <div>
+      <LazyLineChart 
+        data={data} 
+        xKey="month" 
+        yKey="value"
+        height={300}
+        color="#8884d8"
+      />
+    </div>
+  )
+}
+```
+
+### Direct Library Loading
+
+For more control, you can use the library loader directly:
+
+```typescript
+import { loadRecharts, loadD3 } from '@/lib/library-loader'
+
+async function loadChart() {
+  try {
+    const recharts = await loadRecharts()
+    // Use recharts
+  } catch (error) {
+    console.error('Failed to load recharts:', error)
+  }
+}
+```
+
+### Preloading Libraries
+
+To improve perceived performance, you can preload libraries before they're needed:
+
+```typescript
+import { preloadLibrary } from '@/lib/library-loader'
+import { routePreloadManager } from '@/lib/route-preload-manager'
+
+// Preload on hover
+<button 
+  onMouseEnter={() => preloadLibrary('recharts')}
+  onClick={navigateToDashboard}
+>
+  View Dashboard
+</button>
+
+// Preload multiple libraries
+routePreloadManager.preloadLibraries(['recharts', 'd3'])
+```
+
+## Available Libraries
+
+### Recharts
+- **Size**: ~450KB
+- **Use Case**: Business charts (line, bar, pie, area)
+- **Hook**: `useRecharts()`
+- **Preload**: `preloadLibrary('recharts')`
+
+### D3
+- **Size**: ~500KB
+- **Use Case**: Custom data visualizations, complex charts
+- **Hook**: `useD3()`
+- **Preload**: `preloadLibrary('d3')`
+
+### Three.js
+- **Size**: ~600KB
+- **Use Case**: 3D graphics and visualizations
+- **Hook**: `useThree()`
+- **Preload**: `preloadLibrary('three')`
+
+### ReactFlow
+- **Size**: ~300KB
+- **Use Case**: Flow charts, node graphs, diagrams
+- **Hook**: `useReactFlow()`
+- **Preload**: `preloadLibrary('reactflow')`
+
+## Performance Tips
+
+1. **Use Preloading**: Preload libraries when users hover over navigation items or during idle time
+2. **Show Loading States**: Always show skeleton loaders while libraries are loading
+3. **Handle Errors**: Provide fallbacks or retry options when library loading fails
+4. **Batch Loads**: If multiple charts use the same library, they'll automatically share the cached import
+5. **Avoid Over-preloading**: Only preload libraries for routes users are likely to visit
+
+## Implementation Details
+
+### Caching
+Libraries are cached after the first load, so subsequent components using the same library load instantly.
+
+### Retry Logic
+The loader automatically retries failed imports up to 3 times with exponential backoff (1s, 2s, 3s).
+
+### Timeout
+Library loads timeout after 10 seconds to prevent indefinite hangs.
+
+### Bundle Analysis
+To see the impact of lazy loading, run:
+```bash
+npm run build
+# Check the dist/ folder - chart libraries will be in separate chunks
+```
+
+## Migration Guide
+
+### Before (Eager Loading)
+```typescript
+import { LineChart, Line } from 'recharts'
+
+function Chart() {
+  return <LineChart><Line /></LineChart>
+}
+```
+
+### After (Lazy Loading)
+```typescript
+import { useRecharts } from '@/hooks'
+
+function Chart() {
+  const { library: recharts, loading } = useRecharts()
+  
+  if (loading) return <Skeleton />
+  if (!recharts) return null
+  
+  const { LineChart, Line } = recharts
+  return <LineChart><Line /></LineChart>
+}
+```
+
+Or use pre-built components:
+```typescript
+import { LazyLineChart } from '@/components/molecules'
+
+function Chart() {
+  return <LazyLineChart data={data} xKey="x" yKey="y" />
+}
+```
+
+## Console Logging
+
+All library loading is logged to the console with the `[LIBRARY]` prefix for debugging:
+
+- `🎯 Preloading {library}` - Preload started
+- `📦 Loading {library}...` - Load started
+- `✅ {library} loaded successfully` - Load complete
+- `❌ {library} load failed` - Load error
+- `🔁 Retrying {library}` - Retry attempt
+
+## Best Practices
+
+1. **Always handle loading states** - Show skeletons or spinners
+2. **Always handle error states** - Provide user feedback and retry options
+3. **Preload strategically** - On route hover, during idle time, or based on user behavior
+4. **Use pre-built components when possible** - They handle all edge cases
+5. **Monitor bundle size** - Use `npm run build` and check chunk sizes
+
+## Troubleshooting
+
+### Charts not loading
+- Check browser console for `[LIBRARY]` logs
+- Verify network requests are completing (DevTools Network tab)
+- Check for Content Security Policy issues
+
+### Slow loading
+- Ensure libraries are being preloaded on route change
+- Check network conditions and CDN performance
+- Consider reducing the timeout or retry settings
+
+### Type errors
+- The hooks return typed libraries, so TypeScript will help
+- Use `if (!library) return null` before destructuring
+- Check that you're using the correct import path
diff --git a/docs/README.md b/docs/README.md
index 22e8b64..52634bb 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -5,8 +5,9 @@ This directory contains comprehensive documentation for the CodeForge low-code a
 ## 🚀 Quick Start
 
 ### New Features
-- **[Hover-Based Preloading](./hover-preloading.md)** - Instant page navigation (NEW!)
-- **[Preloading Quick Reference](./preloading-quick-reference.md)** - Quick start guide (NEW!)
+- **[Lazy Loading Charts](./LAZY_LOADING_CHARTS.md)** - Lazy-load recharts, d3, three.js (NEW!)
+- **[Hover-Based Preloading](./hover-preloading.md)** - Instant page navigation
+- **[Preloading Quick Reference](./preloading-quick-reference.md)** - Quick start guide
 - **[Router Quick Start](./ROUTER_QUICK_START.md)** - Enable React Router in 2 minutes
 - **[React Router Integration](./REACT_ROUTER_INTEGRATION.md)** - Full router documentation
 
@@ -17,7 +18,8 @@ This directory contains comprehensive documentation for the CodeForge low-code a
 - **[PRD](./PRD.md)** - Product Requirements Document
 
 ### Performance & Optimization
-- **[Bundle Optimization (Monaco Editor)](./bundle-optimization.md)** - Lazy-load heavy components (NEW!)
+- **[Lazy Loading Charts](./LAZY_LOADING_CHARTS.md)** - Lazy-load recharts, d3, three.js (NEW!)
+- **[Bundle Optimization (Monaco Editor)](./bundle-optimization.md)** - Lazy-load heavy components
 - **[Hover-Based Preloading](./hover-preloading.md)** - Instant navigation with preloading
 - **[Preloading Quick Reference](./preloading-quick-reference.md)** - Quick start
 - **[React Router Integration](./REACT_ROUTER_INTEGRATION.md)** - Route-based code splitting
@@ -45,7 +47,26 @@ This directory contains comprehensive documentation for the CodeForge low-code a
 
 ## 🆕 Recent Additions
 
-### Monaco Editor Lazy Loading (Latest)
+### Chart Library Lazy Loading (Latest)
+Optimized bundle size by lazy-loading heavy chart libraries:
+
+**Benefits:**
+- ~1.5MB+ reduction in initial bundle size
+- Charts load only when needed
+- Automatic preloading with hover support
+- Retry logic for network failures
+
+**Libraries optimized:**
+- Recharts (~450KB)
+- D3 (~500KB)
+- Three.js (~600KB)
+- ReactFlow (~300KB)
+
+**Learn more:**
+- [Full Documentation](./LAZY_LOADING_CHARTS.md) - Complete guide
+- [Library Loader API](../src/lib/README.md#library-loaderts) - Technical reference
+
+### Monaco Editor Lazy Loading
 Optimized bundle size by lazy-loading Monaco Editor (2.5MB+):
 
 **Benefits:**
diff --git a/src/components/molecules/LazyBarChart.tsx b/src/components/molecules/LazyBarChart.tsx
new file mode 100644
index 0000000..ded4a04
--- /dev/null
+++ b/src/components/molecules/LazyBarChart.tsx
@@ -0,0 +1,63 @@
+import { useRecharts } from '@/hooks'
+import { Skeleton } from '@/components/ui/skeleton'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Warning } from '@phosphor-icons/react'
+
+interface LazyBarChartProps {
+  data: Array<Record<string, any>>
+  xKey: string
+  yKey: string
+  width?: number
+  height?: number
+  color?: string
+}
+
+export function LazyBarChart({ 
+  data, 
+  xKey, 
+  yKey, 
+  width = 600, 
+  height = 300,
+  color = '#8884d8'
+}: LazyBarChartProps) {
+  const { library: recharts, loading, error } = useRecharts()
+
+  if (loading) {
+    return (
+      <div className="space-y-2">
+        <Skeleton className="h-8 w-32" />
+        <Skeleton className="h-[300px] w-full" />
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <Alert variant="destructive">
+        <Warning className="h-4 w-4" />
+        <AlertDescription>
+          Failed to load chart library. Please refresh the page.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  if (!recharts) {
+    return null
+  }
+
+  const { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } = recharts
+
+  return (
+    <ResponsiveContainer width={width} height={height}>
+      <BarChart data={data}>
+        <CartesianGrid strokeDasharray="3 3" />
+        <XAxis dataKey={xKey} />
+        <YAxis />
+        <Tooltip />
+        <Legend />
+        <Bar dataKey={yKey} fill={color} />
+      </BarChart>
+    </ResponsiveContainer>
+  )
+}
diff --git a/src/components/molecules/LazyD3BarChart.tsx b/src/components/molecules/LazyD3BarChart.tsx
new file mode 100644
index 0000000..3c1dbc5
--- /dev/null
+++ b/src/components/molecules/LazyD3BarChart.tsx
@@ -0,0 +1,87 @@
+import { useD3 } from '@/hooks'
+import { useEffect, useRef } from 'react'
+import { Skeleton } from '@/components/ui/skeleton'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Warning } from '@phosphor-icons/react'
+
+interface LazyD3ChartProps {
+  data: Array<{ label: string; value: number }>
+  width?: number
+  height?: number
+  color?: string
+}
+
+export function LazyD3BarChart({ 
+  data, 
+  width = 600, 
+  height = 300,
+  color = '#8884d8'
+}: LazyD3ChartProps) {
+  const { library: d3, loading, error } = useD3()
+  const svgRef = useRef<SVGSVGElement>(null)
+
+  useEffect(() => {
+    if (!d3 || !svgRef.current || !data.length) return
+
+    const svg = d3.select(svgRef.current)
+    svg.selectAll('*').remove()
+
+    const margin = { top: 20, right: 20, bottom: 30, left: 40 }
+    const chartWidth = width - margin.left - margin.right
+    const chartHeight = height - margin.top - margin.bottom
+
+    const g = svg.append('g')
+      .attr('transform', `translate(${margin.left},${margin.top})`)
+
+    const x = d3.scaleBand()
+      .range([0, chartWidth])
+      .padding(0.1)
+      .domain(data.map(d => d.label))
+
+    const y = d3.scaleLinear()
+      .range([chartHeight, 0])
+      .domain([0, d3.max(data, d => d.value) || 0])
+
+    g.append('g')
+      .attr('transform', `translate(0,${chartHeight})`)
+      .call(d3.axisBottom(x))
+
+    g.append('g')
+      .call(d3.axisLeft(y))
+
+    g.selectAll('.bar')
+      .data(data)
+      .enter().append('rect')
+      .attr('class', 'bar')
+      .attr('x', d => x(d.label) || 0)
+      .attr('y', d => y(d.value))
+      .attr('width', x.bandwidth())
+      .attr('height', d => chartHeight - y(d.value))
+      .attr('fill', color)
+
+  }, [d3, data, width, height, color])
+
+  if (loading) {
+    return (
+      <div className="space-y-2">
+        <Skeleton className="h-8 w-32" />
+        <Skeleton className="h-[300px] w-full" />
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <Alert variant="destructive">
+        <Warning className="h-4 w-4" />
+        <AlertDescription>
+          Failed to load D3 library. Please refresh the page.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  return (
+    <svg ref={svgRef} width={width} height={height} />
+  )
+}
diff --git a/src/components/molecules/LazyLineChart.tsx b/src/components/molecules/LazyLineChart.tsx
new file mode 100644
index 0000000..e4d4dba
--- /dev/null
+++ b/src/components/molecules/LazyLineChart.tsx
@@ -0,0 +1,63 @@
+import { useRecharts } from '@/hooks'
+import { Skeleton } from '@/components/ui/skeleton'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Warning } from '@phosphor-icons/react'
+
+interface LazyLineChartProps {
+  data: Array<Record<string, any>>
+  xKey: string
+  yKey: string
+  width?: number
+  height?: number
+  color?: string
+}
+
+export function LazyLineChart({ 
+  data, 
+  xKey, 
+  yKey, 
+  width = 600, 
+  height = 300,
+  color = '#8884d8'
+}: LazyLineChartProps) {
+  const { library: recharts, loading, error } = useRecharts()
+
+  if (loading) {
+    return (
+      <div className="space-y-2">
+        <Skeleton className="h-8 w-32" />
+        <Skeleton className="h-[300px] w-full" />
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <Alert variant="destructive">
+        <Warning className="h-4 w-4" />
+        <AlertDescription>
+          Failed to load chart library. Please refresh the page.
+        </AlertDescription>
+      </Alert>
+    )
+  }
+
+  if (!recharts) {
+    return null
+  }
+
+  const { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } = recharts
+
+  return (
+    <ResponsiveContainer width={width} height={height}>
+      <LineChart data={data}>
+        <CartesianGrid strokeDasharray="3 3" />
+        <XAxis dataKey={xKey} />
+        <YAxis />
+        <Tooltip />
+        <Legend />
+        <Line type="monotone" dataKey={yKey} stroke={color} />
+      </LineChart>
+    </ResponsiveContainer>
+  )
+}
diff --git a/src/components/molecules/index.ts b/src/components/molecules/index.ts
index c5e45bc..db910ae 100644
--- a/src/components/molecules/index.ts
+++ b/src/components/molecules/index.ts
@@ -8,6 +8,9 @@ export { FileTabs } from './FileTabs'
 export { LabelWithBadge } from './LabelWithBadge'
 export { LazyInlineMonacoEditor } from './LazyInlineMonacoEditor'
 export { LazyMonacoEditor, preloadMonacoEditor } from './LazyMonacoEditor'
+export { LazyLineChart } from './LazyLineChart'
+export { LazyBarChart } from './LazyBarChart'
+export { LazyD3BarChart } from './LazyD3BarChart'
 export { LoadingFallback } from './LoadingFallback'
 export { LoadingState } from './LoadingState'
 export { MonacoEditorPanel } from './MonacoEditorPanel'
diff --git a/src/hooks/core/use-library-loader.ts b/src/hooks/core/use-library-loader.ts
new file mode 100644
index 0000000..4230033
--- /dev/null
+++ b/src/hooks/core/use-library-loader.ts
@@ -0,0 +1,140 @@
+import { useState, useEffect } from 'react'
+import { loadRecharts, loadD3, loadThree, loadReactFlow } from '@/lib/library-loader'
+
+type LoadState<T> = {
+  library: T | null
+  loading: boolean
+  error: Error | null
+}
+
+export function useRecharts() {
+  const [state, setState] = useState<LoadState<typeof import('recharts')>>({
+    library: null,
+    loading: true,
+    error: null,
+  })
+
+  useEffect(() => {
+    console.log('[HOOK] 🎨 useRecharts: Starting load')
+    let mounted = true
+
+    loadRecharts()
+      .then(recharts => {
+        if (mounted) {
+          console.log('[HOOK] ✅ useRecharts: Loaded successfully')
+          setState({ library: recharts, loading: false, error: null })
+        }
+      })
+      .catch(error => {
+        if (mounted) {
+          console.error('[HOOK] ❌ useRecharts: Load failed', error)
+          setState({ library: null, loading: false, error })
+        }
+      })
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  return state
+}
+
+export function useD3() {
+  const [state, setState] = useState<LoadState<typeof import('d3')>>({
+    library: null,
+    loading: true,
+    error: null,
+  })
+
+  useEffect(() => {
+    console.log('[HOOK] 📊 useD3: Starting load')
+    let mounted = true
+
+    loadD3()
+      .then(d3 => {
+        if (mounted) {
+          console.log('[HOOK] ✅ useD3: Loaded successfully')
+          setState({ library: d3, loading: false, error: null })
+        }
+      })
+      .catch(error => {
+        if (mounted) {
+          console.error('[HOOK] ❌ useD3: Load failed', error)
+          setState({ library: null, loading: false, error })
+        }
+      })
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  return state
+}
+
+export function useThree() {
+  const [state, setState] = useState<LoadState<typeof import('three')>>({
+    library: null,
+    loading: true,
+    error: null,
+  })
+
+  useEffect(() => {
+    console.log('[HOOK] 🎮 useThree: Starting load')
+    let mounted = true
+
+    loadThree()
+      .then(three => {
+        if (mounted) {
+          console.log('[HOOK] ✅ useThree: Loaded successfully')
+          setState({ library: three, loading: false, error: null })
+        }
+      })
+      .catch(error => {
+        if (mounted) {
+          console.error('[HOOK] ❌ useThree: Load failed', error)
+          setState({ library: null, loading: false, error })
+        }
+      })
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  return state
+}
+
+export function useReactFlow() {
+  const [state, setState] = useState<LoadState<typeof import('reactflow')>>({
+    library: null,
+    loading: true,
+    error: null,
+  })
+
+  useEffect(() => {
+    console.log('[HOOK] 🔀 useReactFlow: Starting load')
+    let mounted = true
+
+    loadReactFlow()
+      .then(reactflow => {
+        if (mounted) {
+          console.log('[HOOK] ✅ useReactFlow: Loaded successfully')
+          setState({ library: reactflow, loading: false, error: null })
+        }
+      })
+      .catch(error => {
+        if (mounted) {
+          console.error('[HOOK] ❌ useReactFlow: Load failed', error)
+          setState({ library: null, loading: false, error })
+        }
+      })
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  return state
+}
diff --git a/src/hooks/index.ts b/src/hooks/index.ts
index b61d36d..4e63281 100644
--- a/src/hooks/index.ts
+++ b/src/hooks/index.ts
@@ -1,6 +1,7 @@
 export * from './core/use-kv-state'
 export * from './core/use-debounced-save'
 export * from './core/use-clipboard'
+export * from './core/use-library-loader'
 
 export * from './ui/use-dialog'
 export * from './ui/use-selection'
diff --git a/src/lib/README.md b/src/lib/README.md
index ee836f4..a1e505e 100644
--- a/src/lib/README.md
+++ b/src/lib/README.md
@@ -130,6 +130,67 @@ if (loader.isLoaded('MyComponent')) {
 loader.reset()
 ```
 
+### `library-loader.ts`
+
+Lazy loading utilities for heavy chart and visualization libraries.
+
+**Supported Libraries:**
+- Recharts (~450KB)
+- D3 (~500KB)
+- Three.js (~600KB)
+- ReactFlow (~300KB)
+
+**Key Functions:**
+
+#### `loadRecharts()`, `loadD3()`, `loadThree()`, `loadReactFlow()`
+Load libraries with retry logic and caching.
+
+**Usage:**
+```typescript
+import { loadRecharts, loadD3 } from '@/lib/library-loader'
+
+async function loadChart() {
+  const recharts = await loadRecharts()
+  // Use recharts
+}
+```
+
+#### `preloadLibrary(libraryName)`
+Preload library before it's needed.
+
+**Usage:**
+```typescript
+import { preloadLibrary } from '@/lib/library-loader'
+
+// Preload on hover
+<button onMouseEnter={() => preloadLibrary('recharts')}>
+  View Charts
+</button>
+```
+
+#### `clearLibraryCache()`
+Clear all cached library imports.
+
+**React Hooks:**
+Use with hooks for automatic loading state management:
+
+```typescript
+import { useRecharts, useD3 } from '@/hooks'
+
+function Chart() {
+  const { library: recharts, loading, error } = useRecharts()
+  
+  if (loading) return <Skeleton />
+  if (error) return <Alert>Failed to load</Alert>
+  if (!recharts) return null
+  
+  const { LineChart } = recharts
+  return <LineChart />
+}
+```
+
+**See `/docs/LAZY_LOADING_CHARTS.md` for complete documentation.**
+
 ### `utils.ts`
 
 General utility functions (shadcn standard).
diff --git a/src/lib/library-loader.ts b/src/lib/library-loader.ts
new file mode 100644
index 0000000..bb7559d
--- /dev/null
+++ b/src/lib/library-loader.ts
@@ -0,0 +1,111 @@
+const libraryCache = new Map<string, Promise<any>>()
+
+interface LibraryLoadOptions {
+  timeout?: number
+  retries?: number
+}
+
+async function loadWithRetry<T>(
+  libraryName: string,
+  importFn: () => Promise<T>,
+  options: LibraryLoadOptions = {}
+): Promise<T> {
+  const { timeout = 10000, retries = 3 } = options
+
+  if (libraryCache.has(libraryName)) {
+    console.log(`[LIBRARY] ✅ ${libraryName} already loaded from cache`)
+    return libraryCache.get(libraryName)!
+  }
+
+  console.log(`[LIBRARY] 📦 Loading ${libraryName}...`)
+
+  const loadPromise = new Promise<T>((resolve, reject) => {
+    let attempts = 0
+
+    const attemptLoad = async () => {
+      attempts++
+      console.log(`[LIBRARY] 🔄 Loading ${libraryName} (attempt ${attempts}/${retries})`)
+
+      const timeoutId = setTimeout(() => {
+        console.warn(`[LIBRARY] ⏰ ${libraryName} load timeout after ${timeout}ms`)
+        reject(new Error(`${libraryName} load timeout after ${timeout}ms`))
+      }, timeout)
+
+      try {
+        const library = await importFn()
+        clearTimeout(timeoutId)
+        console.log(`[LIBRARY] ✅ ${libraryName} loaded successfully`)
+        resolve(library)
+      } catch (error) {
+        clearTimeout(timeoutId)
+        console.error(`[LIBRARY] ❌ ${libraryName} load failed (attempt ${attempts}):`, error)
+
+        if (attempts < retries) {
+          console.log(`[LIBRARY] 🔁 Retrying ${libraryName} in ${attempts * 1000}ms...`)
+          setTimeout(attemptLoad, attempts * 1000)
+        } else {
+          console.error(`[LIBRARY] ❌ ${libraryName} all retry attempts exhausted`)
+          reject(error)
+        }
+      }
+    }
+
+    attemptLoad()
+  })
+
+  libraryCache.set(libraryName, loadPromise)
+  return loadPromise
+}
+
+export async function loadRecharts() {
+  return loadWithRetry('recharts', () => import('recharts'))
+}
+
+export async function loadD3() {
+  return loadWithRetry('d3', () => import('d3'))
+}
+
+export async function loadThree() {
+  return loadWithRetry('three', () => import('three'))
+}
+
+export async function loadReactFlow() {
+  return loadWithRetry('reactflow', () => import('reactflow'))
+}
+
+export function preloadLibrary(libraryName: 'recharts' | 'd3' | 'three' | 'reactflow') {
+  console.log(`[LIBRARY] 🎯 Preloading ${libraryName}`)
+  
+  switch (libraryName) {
+    case 'recharts':
+      loadRecharts().catch(err => console.warn(`[LIBRARY] ⚠️ Preload failed for recharts:`, err))
+      break
+    case 'd3':
+      loadD3().catch(err => console.warn(`[LIBRARY] ⚠️ Preload failed for d3:`, err))
+      break
+    case 'three':
+      loadThree().catch(err => console.warn(`[LIBRARY] ⚠️ Preload failed for three:`, err))
+      break
+    case 'reactflow':
+      loadReactFlow().catch(err => console.warn(`[LIBRARY] ⚠️ Preload failed for reactflow:`, err))
+      break
+  }
+}
+
+export function getLibraryLoadStatus(libraryName: string): 'not-loaded' | 'loading' | 'loaded' | 'error' {
+  if (!libraryCache.has(libraryName)) {
+    return 'not-loaded'
+  }
+
+  const promise = libraryCache.get(libraryName)!
+  
+  return promise.then(
+    () => 'loaded',
+    () => 'error'
+  ) as any
+}
+
+export function clearLibraryCache() {
+  console.log('[LIBRARY] 🧹 Clearing library cache')
+  libraryCache.clear()
+}
diff --git a/src/lib/route-preload-manager.ts b/src/lib/route-preload-manager.ts
index 217c519..9856242 100644
--- a/src/lib/route-preload-manager.ts
+++ b/src/lib/route-preload-manager.ts
@@ -1,6 +1,7 @@
 import { getEnabledPages } from '@/config/page-loader'
 import { preloadComponentByName, ComponentName } from '@/lib/component-registry'
 import { FeatureToggles } from '@/types/project'
+import { preloadLibrary } from '@/lib/library-loader'
 
 interface PreloadStrategy {
   preloadAdjacent: boolean
@@ -148,6 +149,13 @@ export class RoutePreloadManager {
     })
   }
 
+  preloadLibraries(libraries: Array<'recharts' | 'd3' | 'three' | 'reactflow'>) {
+    console.log('[PRELOAD_MGR] 📚 Preloading libraries:', libraries)
+    libraries.forEach(lib => {
+      preloadLibrary(lib)
+    })
+  }
+
   isPreloaded(pageId: string): boolean {
     return this.preloadedRoutes.has(pageId)
   }