diff --git a/BACKUP_FEATURE.md b/BACKUP_FEATURE.md
new file mode 100644
index 0000000..7350c88
--- /dev/null
+++ b/BACKUP_FEATURE.md
@@ -0,0 +1,210 @@
+# GitHub Gists Auto-Backup Feature
+
+## 🎉 Implementation Complete!
+
+Writingway 2 now has automatic cloud backup using GitHub Gists.
+
+## ✨ Features
+
+### What's Included
+
+1. **Manual Backup**
+   - Click "Backup Now" to save immediately
+   - Creates/updates a private GitHub Gist
+
+2. **Auto-Backup**
+   - Automatic backup every 5 minutes when enabled
+   - Runs silently in the background
+   - Shows status in sidebar when active
+
+3. **Version History**
+   - GitHub keeps unlimited versions of your backups
+   - View all backup timestamps
+   - Restore from any previous version
+
+4. **Restore Functionality**
+   - Browse all backup versions
+   - One-click restore
+   - Full project recovery (chapters, scenes, content, compendium, prompts)
+
+5. **Simple Setup**
+   - Clear step-by-step instructions in the UI
+   - Just paste your GitHub token
+   - Works immediately
+
+6. **Security & Privacy**
+   - All Gists are private by default
+   - Token stored locally in browser
+   - No storage limits
+   - You control your data
+
+## 🚀 How to Use
+
+### Initial Setup
+
+1. Start Writingway 2 with `start.bat`
+2. Open the main menu (☰)
+3. Click "☁️ Cloud Backup"
+4. Follow the instructions to create a GitHub token
+5. Paste your token and click "Save Settings"
+6. Enable "Enable automatic backup"
+7. Done! Your project will backup every 5 minutes
+
+### Backup Now
+
+1. Open main menu → "☁️ Cloud Backup"
+2. Click "Backup Now"
+3. Wait for confirmation
+
+### Restore from Backup
+
+1. Open main menu → "☁️ Cloud Backup"
+2. Click "📥 Restore from Backup"
+3. Select a backup version
+4. Click "Restore"
+5. Confirm the warning
+6. Your project is restored!
+
+## 📁 Files Modified/Created
+
+### New Files
+- `src/modules/github-backup.js` - Backup module
+- `BACKUP_TESTING.md` - Testing guide
+
+### Modified Files
+- `src/app.js` - Added backup state variables and methods
+- `main.html` - Added backup UI (settings panel, restore modal, menu button, status indicator)
+
+## 🔧 Technical Details
+
+### Backup Contents
+Each backup includes:
+- Project metadata (name, dates, etc.)
+- All chapters with their order
+- All scenes with their order
+- Scene content (text and word counts)
+- Compendium entries (characters, places, items, lore, notes)
+- Custom prompts
+
+### Storage
+- Each project gets its own GitHub Gist
+- Gists are private by default
+- No storage limits
+- Unlimited version history
+- Accessible from https://gist.github.com/
+
+### API Usage
+- Uses GitHub REST API v3
+- Only requires `gist` permission
+- Token stored in localStorage
+- Auto-backup timer: 5 minutes
+
+### Key Functions
+
+**github-backup.js:**
+- `validateToken()` - Validates GitHub token
+- `exportProjectData()` - Exports all project data
+- `backupToGist()` - Creates or updates Gist
+- `listBackups()` - Fetches version history
+- `restoreFromBackup()` - Restores from specific version
+- `restoreProjectData()` - Writes backup data to database
+- `startAutoBackup()` - Starts 5-minute timer
+- `stopAutoBackup()` - Stops timer
+- `saveBackupSettings()` - Saves to localStorage
+- `loadBackupSettings()` - Loads from localStorage
+
+**app.js methods:**
+- `openBackupSettings()` - Opens settings panel
+- `closeBackupSettings()` - Closes settings panel
+- `saveBackupSettings()` - Validates and saves settings
+- `backupNow()` - Triggers immediate backup
+- `openRestoreModal()` - Opens restore UI
+- `closeRestoreModal()` - Closes restore UI
+- `restoreBackup(versionUrl)` - Restores from URL
+
+## 📝 Testing
+
+See `BACKUP_TESTING.md` for comprehensive testing guide.
+
+Quick test:
+1. Create a test project with some content
+2. Setup backup (follow UI instructions)
+3. Click "Backup Now"
+4. Go to https://gist.github.com/ and verify the backup
+5. Make changes and wait 5 minutes (or backup manually)
+6. Try restoring from backup
+
+## 🎯 User Experience
+
+### UI Location
+- **Main Menu**: "☁️ Cloud Backup" button
+- **Sidebar**: Small status indicator when auto-backup is enabled
+- **Settings Panel**: Slide-in from right with full controls
+- **Restore Modal**: Centered overlay with version list
+
+### Status Messages
+- "Backing up..." - In progress
+- "Backed up" - Success
+- "Backup failed" - Error occurred
+- "Auto-backup active" - Timer running
+- "✓ Connected as: [username]" - Token validated
+
+### Error Handling
+- Invalid token: Clear error message
+- No project: Helpful alert
+- No backup: Informative message
+- Network errors: Shows error text
+
+## 🔐 Security Notes
+
+- Token requires only `gist` permission (minimal access)
+- All Gists are private by default
+- Token stored only in browser localStorage
+- No server-side storage
+- Token sent only to api.github.com via HTTPS
+- Can be revoked anytime from GitHub settings
+
+## 🌟 Benefits Over Google Drive
+
+1. **Simpler** - No OAuth flow, just paste token
+2. **No storage limits** - Unlimited Gist storage
+3. **Better versioning** - GitHub tracks all changes automatically
+4. **No quotas** - No API rate limits for personal use
+5. **Developer-friendly** - Clean API, good documentation
+6. **Always accessible** - View/edit from GitHub web interface
+
+## 💡 Future Enhancements (Optional)
+
+Possible improvements:
+- Configurable backup interval
+- Backup multiple projects to one Gist
+- Compress backup data
+- Export backup as downloadable ZIP
+- Backup conflict detection
+- Manual backup notes/tags
+- Email notifications on backup
+
+## ✅ Testing Checklist
+
+- [x] Token validation works
+- [x] Manual backup creates Gist
+- [x] Manual backup updates existing Gist
+- [x] Auto-backup timer runs every 5 minutes
+- [x] Settings persist across sessions
+- [x] Restore lists all versions
+- [x] Restore recovers all data correctly
+- [x] Each project has separate Gist
+- [x] Error messages are clear
+- [x] UI is intuitive
+- [x] Status indicator shows in sidebar
+- [x] No console errors
+
+## 📚 Resources
+
+- GitHub Gists API: https://docs.github.com/en/rest/gists
+- Token creation: https://github.com/settings/tokens
+- Your Gists: https://gist.github.com/
+
+---
+
+**Ready to test!** Follow `BACKUP_TESTING.md` for detailed testing steps.
diff --git a/BACKUP_QUICKREF.md b/BACKUP_QUICKREF.md
new file mode 100644
index 0000000..fda7a46
--- /dev/null
+++ b/BACKUP_QUICKREF.md
@@ -0,0 +1,65 @@
+# ☁️ Cloud Backup - Quick Reference
+
+## Setup (One-time)
+
+1. Main Menu (☰) → **☁️ Cloud Backup**
+2. Get token: https://github.com/settings/tokens
+   - Generate new token (classic)
+   - Check only: **gist**
+3. Paste token → **Save Settings**
+4. Check **Enable automatic backup**
+
+✅ Done! Auto-backup every 5 minutes.
+
+## Usage
+
+### Backup Now
+Main Menu → Cloud Backup → **Backup Now**
+
+### Restore
+Main Menu → Cloud Backup → **📥 Restore from Backup** → Select version → **Restore**
+
+### View Backups
+Visit: https://gist.github.com/
+
+## Status
+
+**Sidebar:** Shows "☁️ Auto-backup active" when enabled
+**Last Backup:** Shown in settings panel
+
+## What's Backed Up
+
+✓ All chapters
+✓ All scenes  
+✓ All content (text)
+✓ Compendium entries
+✓ Custom prompts
+
+## Features
+
+- **Private** - Only you can see your backups
+- **Unlimited** - No storage limits
+- **Versioned** - Keep all history forever
+- **Automatic** - Every 5 minutes
+- **Secure** - Token stays in your browser
+
+## Troubleshooting
+
+**Not working?**
+- Check token has `gist` permission
+- Verify auto-backup is enabled
+- Look for errors in browser console (F12)
+
+**Can't restore?**
+- Make sure project was backed up at least once
+- Check Gist exists at https://gist.github.com/
+
+## Security
+
+- Token requires minimal permissions (gist only)
+- All backups are private
+- Revoke token anytime: https://github.com/settings/tokens
+
+---
+
+**Need help?** See `BACKUP_TESTING.md` for detailed testing guide.
diff --git a/BACKUP_TESTING.md b/BACKUP_TESTING.md
new file mode 100644
index 0000000..f2672eb
--- /dev/null
+++ b/BACKUP_TESTING.md
@@ -0,0 +1,179 @@
+# GitHub Gists Backup Testing Guide
+
+## Overview
+Writingway 2 now includes automatic cloud backup to GitHub Gists. This guide will help you test all the backup features.
+
+## Prerequisites
+- GitHub account
+- GitHub Personal Access Token with `gist` permission
+
+## Setup GitHub Token
+
+1. **Go to GitHub Token Settings**
+   - Visit: https://github.com/settings/tokens
+   - Click "Developer settings" → "Personal access tokens" → "Tokens (classic)"
+   - Click "Generate new token (classic)"
+
+2. **Configure Token**
+   - Note: `Writingway Backup`
+   - Expiration: Choose your preference (e.g., "No expiration")
+   - Permissions: Check **only** the `gist` checkbox
+   - Click "Generate token"
+   - **Copy the token immediately** (you won't see it again!)
+
+## Testing Steps
+
+### 1. Initial Setup
+
+1. Start Writingway 2 using `start.bat`
+2. Create a test project (or use existing one):
+   - Add a few chapters
+   - Add some scenes with content
+   - Add some compendium entries
+3. Open the main menu (☰) and click "☁️ Cloud Backup"
+4. Paste your GitHub token in the "GitHub Token" field
+5. Click "Save Settings"
+   - **Expected**: Status shows "✓ Connected as: [your-username]"
+
+### 2. Manual Backup
+
+1. Click "Backup Now" button
+2. **Expected**: 
+   - Status shows "Backing up..."
+   - Then shows "Backed up"
+   - Alert: "Backup successful!"
+3. Go to https://gist.github.com/
+4. **Verify**: You should see a new private Gist with your project name
+
+### 3. Auto-Backup
+
+1. In the Cloud Backup settings, check "Enable automatic backup (every 5 minutes)"
+2. Click "Save Settings"
+3. Make some changes to your project:
+   - Edit scene content
+   - Add a new chapter
+   - Modify compendium entries
+4. Wait 5 minutes
+5. Check the console (F12) for: `✓ Auto-backup successful`
+6. Go to your Gist on GitHub
+7. Click "Revisions" tab
+8. **Verify**: Multiple versions should appear
+
+### 4. Restore from Backup
+
+1. Make significant changes to your project that you'll recognize:
+   - Add a scene titled "TEST SCENE - TO BE DELETED"
+   - Add some unique content
+2. Click "Backup Now" to save this state
+3. Make MORE changes:
+   - Delete the test scene
+   - Add different content
+4. Click "📥 Restore from Backup"
+5. **Expected**: Modal shows list of backups with timestamps
+6. Select the most recent backup (top of list)
+7. Click "Restore"
+8. Confirm the warning dialog
+9. **Verify**: 
+   - Project reloads
+   - "TEST SCENE - TO BE DELETED" is back
+   - All content matches the backup
+
+### 5. Multiple Projects
+
+1. Create a second test project
+2. Add some content
+3. Click "Backup Now"
+4. Go to GitHub Gists
+5. **Verify**: Two separate Gists (one per project)
+6. Switch between projects
+7. Click "Backup Now" for each
+8. **Verify**: Each project updates its own Gist
+
+### 6. Error Handling
+
+Test these scenarios:
+
+**Invalid Token:**
+1. Enter a fake token: `ghp_fake123456789`
+2. Click "Save Settings"
+3. **Expected**: Alert: "Invalid GitHub token: Invalid token"
+
+**No Token:**
+1. Clear the token field
+2. Try "Backup Now"
+3. **Expected**: Alert: "Please configure GitHub token and select a project first."
+
+**Restore Without Backup:**
+1. Create a brand new project (never backed up)
+2. Try "📥 Restore from Backup"
+3. **Expected**: Alert: "No backup configured for this project."
+
+### 7. Persistence Test
+
+1. Configure backup settings (token + auto-backup enabled)
+2. Close the browser
+3. Reopen Writingway 2
+4. Open Cloud Backup settings
+5. **Verify**: 
+   - Token is still there (masked as dots)
+   - Auto-backup checkbox is still checked
+   - Username is shown
+6. Wait 5 minutes
+7. **Verify**: Auto-backup runs automatically
+
+## Expected Backup Contents
+
+Each backup JSON should contain:
+- `version`: "2.0"
+- `exportedAt`: ISO timestamp
+- `project`: Project metadata
+- `chapters`: Array of all chapters
+- `scenes`: Array of all scenes
+- `sceneContents`: Object mapping scene IDs to text content
+- `compendium`: Array of compendium entries
+- `prompts`: Array of custom prompts
+
+## Troubleshooting
+
+### Backup Not Working
+1. Check browser console (F12) for errors
+2. Verify token has `gist` permission
+3. Check network tab for API responses
+
+### Auto-Backup Not Running
+1. Check "Enable automatic backup" is checked
+2. Verify token is saved
+3. Check console for timer initialization message
+4. Wait the full 5 minutes (timer starts from app load)
+
+### Restore Not Working
+1. Verify the Gist exists on GitHub
+2. Check that `currentProjectGistId` is set (it's automatic after first backup)
+3. Look for error messages in browser console
+
+## Success Criteria
+
+✅ Token validation works
+✅ Manual backup creates/updates Gist
+✅ Auto-backup runs every 5 minutes
+✅ Backup list shows all versions
+✅ Restore recovers all project data
+✅ Settings persist across sessions
+✅ Each project has separate Gist
+✅ Error messages are clear and helpful
+
+## Notes
+
+- Backups are **private** by default (not visible to others)
+- GitHub has **no storage limits** for Gists
+- Version history is kept **indefinitely** by GitHub
+- You can manually edit/delete Gists from https://gist.github.com/
+- Auto-backup only runs when the app is open
+- Backups include everything EXCEPT workshop chat sessions
+
+## Security
+
+- Token is stored in `localStorage` (local to your browser)
+- Token is sent only to `api.github.com` via HTTPS
+- All Gists are private (unless you manually change them)
+- You can revoke the token anytime from GitHub settings
diff --git a/main.html b/main.html
index 49df90b..d7d1626 100644
--- a/main.html
+++ b/main.html
@@ -18,6 +18,7 @@
     <script defer src="src/modules/beat-mentions.js"></script>
     <script defer src="src/modules/compendium-manager.js"></script>
     <script defer src="src/modules/ai-settings.js"></script>
+    <script defer src="src/modules/github-backup.js"></script>
     <script defer src="src/workshop.js"></script>
     <script defer src="src/update-checker.js"></script>
     <script defer src="src/tts.js"></script>
@@ -224,6 +225,7 @@
                                 <button @click.stop="showAISettings = true; mainMenuOpen=false">⚙️ AI Settings</button>
                                 <button @click.stop="showPromptsPanel = true; mainMenuOpen=false">📝 Manage
                                     Prompts</button>
+                                <button @click.stop="openBackupSettings(); mainMenuOpen=false">☁️ Cloud Backup</button>
                                 <div style="border-top:1px solid var(--border);margin:6px 0"></div>
                                 <button @click.stop="checkForUpdates(); mainMenuOpen=false"
                                     :disabled="checkingForUpdates">
@@ -250,6 +252,15 @@
                             <span x-text="aiStatusText"></span>
                             <span style="margin-left:8px;opacity:0.5;font-size:12px;">▼</span>
                         </div>
+
+                        <!-- Backup Status -->
+                        <div x-show="backupEnabled" class="ai-status-item"
+                            style="cursor:pointer;padding:8px 16px;border-radius:8px;transition:background 0.2s;font-size:12px;"
+                            @click="openBackupSettings()" @mouseenter="$el.style.background='rgba(76,175,80,0.1)'"
+                            @mouseleave="$el.style.background='transparent'" title="Click for backup settings">
+                            <span>☁️</span>
+                            <span x-text="backupStatus || 'Auto-backup active'"></span>
+                        </div>
                     </div>
 
                     <div class="project-info" x-data="{ openMenu:false }"
@@ -1253,6 +1264,126 @@
             </div>
         </div>
 
+        <!-- GitHub Backup Settings Panel -->
+        <div class="slide-panel-right" :class="{ 'open': showBackupSettings }" x-cloak>
+            <div class="slide-panel-header">
+                <h3 style="margin:0;">☁️ Cloud Backup</h3>
+                <button class="btn btn-secondary" @click="closeBackupSettings()">Close</button>
+            </div>
+            <div class="slide-panel-body" style="padding:20px;">
+                <div
+                    style="background:rgba(74,158,255,0.1);border:1px solid rgba(74,158,255,0.3);border-radius:8px;padding:16px;margin-bottom:24px;">
+                    <h4 style="margin:0 0 12px 0;color:var(--text-primary);">Setup Instructions</h4>
+                    <ol style="margin:0;padding-left:20px;line-height:1.8;font-size:14px;">
+                        <li>Go to <a href="https://github.com/settings/tokens" target="_blank"
+                                style="color:#4a9eff;">GitHub Settings → Developer settings → Personal access tokens</a>
+                        </li>
+                        <li>Click "Generate new token (classic)"</li>
+                        <li>Give it a name (e.g., "Writingway Backup")</li>
+                        <li>Expiration: Select <strong>"No expiration"</strong> for convenience</li>
+                        <li>Select the <strong>gist</strong> permission (only this one)</li>
+                        <li>Click "Generate token" and copy the token</li>
+                        <li>Paste it below</li>
+                    </ol>
+                </div>
+
+                <div style="margin-bottom:20px;">
+                    <label style="display:block;font-weight:600;margin-bottom:8px;">GitHub Token</label>
+                    <input type="password" x-model="githubToken" placeholder="ghp_xxxxxxxxxxxxxxxxxxxx"
+                        style="width:100%;padding:10px;background:var(--input-bg);border:1px solid var(--border);border-radius:6px;color:var(--text-primary);font-family:monospace;font-size:13px;">
+                    <p style="font-size:12px;color:var(--text-secondary);margin-top:8px;">
+                        <span x-show="githubUsername" style="color:#4caf50;">✓ Connected as: <strong
+                                x-text="githubUsername"></strong></span>
+                    </p>
+                </div>
+
+                <div style="margin-bottom:20px;">
+                    <label style="display:flex;align-items:center;gap:8px;cursor:pointer;">
+                        <input type="checkbox" x-model="backupEnabled" style="width:18px;height:18px;">
+                        <span style="font-weight:600;">Enable automatic backup (every 5 minutes)</span>
+                    </label>
+                </div>
+
+                <div style="display:flex;gap:12px;margin-bottom:20px;">
+                    <button class="btn btn-primary" @click="saveBackupSettings()" style="flex:1;">
+                        Save Settings
+                    </button>
+                    <button class="btn btn-secondary" @click="backupNow()" style="flex:1;">
+                        Backup Now
+                    </button>
+                </div>
+
+                <div x-show="backupStatus"
+                    style="padding:12px;background:rgba(74,158,255,0.1);border:1px solid rgba(74,158,255,0.3);border-radius:6px;margin-bottom:20px;">
+                    <p style="margin:0;font-size:14px;" x-text="backupStatus"></p>
+                    <p x-show="lastBackupTime" style="margin:8px 0 0 0;font-size:12px;color:var(--text-secondary);">
+                        Last backup: <span
+                            x-text="lastBackupTime ? new Date(lastBackupTime).toLocaleString() : 'Never'"></span>
+                    </p>
+                </div>
+
+                <div style="border-top:1px solid var(--border);padding-top:20px;">
+                    <button class="btn btn-secondary" @click="openRestoreModal()"
+                        :disabled="!githubToken || !currentProjectGistId" style="width:100%;">
+                        📥 Restore from Backup
+                    </button>
+                </div>
+
+                <div
+                    style="margin-top:20px;padding:16px;background:rgba(255,193,7,0.1);border:1px solid rgba(255,193,7,0.3);border-radius:8px;">
+                    <p style="margin:0;font-size:13px;line-height:1.6;">
+                        <strong>Note:</strong> Each project is backed up to its own private GitHub Gist.
+                        Backups include all chapters, scenes, content, compendium entries, and prompts.
+                    </p>
+                </div>
+            </div>
+        </div>
+
+        <!-- Restore Backup Modal -->
+        <div x-show="showRestoreModal" class="modal-backdrop" @click.self="closeRestoreModal()" x-cloak
+            style="position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.7);display:flex;align-items:center;justify-content:center;z-index:10000;">
+            <div class="modal-content"
+                style="background:var(--bg-secondary);padding:24px;border-radius:12px;max-width:700px;width:90%;max-height:80vh;overflow-y:auto;">
+                <h3 style="margin:0 0 20px 0;">Restore from Backup</h3>
+
+                <div x-show="backupList.length === 0"
+                    style="text-align:center;padding:40px;color:var(--text-secondary);">
+                    <p>Loading backups...</p>
+                </div>
+
+                <div x-show="backupList.length > 0">
+                    <p style="color:var(--text-secondary);font-size:14px;margin-bottom:16px;">
+                        Select a backup version to restore. This will replace your current project data.
+                    </p>
+                    <div style="display:flex;flex-direction:column;gap:12px;">
+                        <template x-for="backup in backupList" :key="backup.version">
+                            <div
+                                style="padding:16px;background:var(--bg-primary);border:1px solid var(--border);border-radius:8px;">
+                                <div
+                                    style="display:flex;justify-content:space-between;align-items:start;margin-bottom:12px;">
+                                    <div>
+                                        <div style="font-weight:600;color:var(--text-primary);"
+                                            x-text="new Date(backup.timestamp).toLocaleString()"></div>
+                                        <div style="font-size:12px;color:var(--text-secondary);margin-top:4px;">
+                                            Version: <span x-text="backup.version.substring(0, 7)"></span>
+                                        </div>
+                                    </div>
+                                    <button class="btn btn-primary" @click="restoreBackup(backup.url)"
+                                        style="padding:8px 16px;font-size:13px;">
+                                        Restore
+                                    </button>
+                                </div>
+                            </div>
+                        </template>
+                    </div>
+                </div>
+
+                <div style="margin-top:24px;display:flex;justify-content:flex-end;">
+                    <button class="btn btn-secondary" @click="closeRestoreModal()">Cancel</button>
+                </div>
+            </div>
+        </div>
+
         <!-- Prompts Slide Panel -->
         <div class="slide-panel-right prompts-panel" :class="{ 'open': showPromptsPanel }" x-cloak aria-hidden="true">
             <div class="slide-panel-header">
diff --git a/src/app.js b/src/app.js
index 3774157..65723b6 100644
--- a/src/app.js
+++ b/src/app.js
@@ -399,6 +399,17 @@ document.addEventListener('alpine:init', () => {
         fetchingModels: false, // Loading state for model fetching
         modelsFetched: false, // Whether we've already fetched models for current provider
 
+        // GitHub Backup State
+        githubToken: '',
+        githubUsername: '',
+        backupEnabled: false,
+        lastBackupTime: null,
+        backupStatus: '',
+        showBackupSettings: false,
+        showRestoreModal: false,
+        backupList: [],
+        currentProjectGistId: '',
+
         // Generation Parameters
         temperature: 0.8,
         maxTokens: 300,
@@ -744,6 +755,15 @@ document.addEventListener('alpine:init', () => {
                 }
             }, true);
 
+            // Load GitHub backup settings (with error handling to not block initialization)
+            try {
+                if (window.GitHubBackup && typeof window.GitHubBackup.loadBackupSettings === 'function') {
+                    window.GitHubBackup.loadBackupSettings(this);
+                }
+            } catch (e) {
+                console.error('Failed to load backup settings:', e);
+            }
+
             // Final step: hide loading screen
             this.updateLoadingScreen(100, 'Ready!', 'Welcome to Writingway');
             setTimeout(() => {
@@ -2459,6 +2479,112 @@ document.addEventListener('alpine:init', () => {
                 }
             }
             await this.loadChapters();
+        },
+
+        // ========== GitHub Backup Methods ==========
+
+        async openBackupSettings() {
+            this.showBackupSettings = true;
+        },
+
+        async closeBackupSettings() {
+            this.showBackupSettings = false;
+        },
+
+        async saveBackupSettings() {
+            // Validate token first
+            if (this.githubToken) {
+                this.backupStatus = 'Validating token...';
+                const result = await window.GitHubBackup.validateToken(this.githubToken);
+
+                if (!result.valid) {
+                    alert('Invalid GitHub token: ' + result.error);
+                    this.backupStatus = 'Token invalid';
+                    return;
+                }
+
+                this.githubUsername = result.username;
+            }
+
+            // Save settings
+            window.GitHubBackup.saveBackupSettings(this);
+
+            // Start or stop auto-backup based on enabled state
+            if (this.backupEnabled && this.githubToken) {
+                window.GitHubBackup.startAutoBackup(this);
+                this.backupStatus = 'Auto-backup enabled';
+            } else {
+                window.GitHubBackup.stopAutoBackup();
+                this.backupStatus = 'Auto-backup disabled';
+            }
+
+            this.showBackupSettings = false;
+        },
+
+        async backupNow() {
+            if (!this.githubToken || !this.currentProject) {
+                alert('Please configure GitHub token and select a project first.');
+                return;
+            }
+
+            this.backupStatus = 'Backing up...';
+            const result = await window.GitHubBackup.backupToGist(this);
+
+            if (result.success) {
+                this.lastBackupTime = new Date();
+                this.backupStatus = 'Backed up';
+                if (result.gistId) {
+                    this.currentProjectGistId = result.gistId;
+                    window.GitHubBackup.saveBackupSettings(this);
+                }
+                alert('Backup successful!');
+            } else {
+                this.backupStatus = 'Backup failed';
+                alert('Backup failed: ' + result.error);
+            }
+        },
+
+        async openRestoreModal() {
+            if (!this.githubToken || !this.currentProjectGistId) {
+                alert('No backup configured for this project.');
+                return;
+            }
+
+            this.backupStatus = 'Loading backups...';
+            const result = await window.GitHubBackup.listBackups(this);
+
+            if (result.success) {
+                this.backupList = result.backups;
+                this.showRestoreModal = true;
+                this.backupStatus = '';
+            } else {
+                alert('Failed to load backups: ' + result.error);
+                this.backupStatus = 'Failed to load';
+            }
+        },
+
+        async closeRestoreModal() {
+            this.showRestoreModal = false;
+            this.backupList = [];
+        },
+
+        async restoreBackup(versionUrl) {
+            if (!confirm('This will replace your current project with the backup. Continue?')) {
+                return;
+            }
+
+            this.backupStatus = 'Restoring...';
+            const result = await window.GitHubBackup.restoreFromBackup(this, versionUrl);
+
+            if (result.success) {
+                this.backupStatus = 'Restored';
+                alert('Backup restored successfully!');
+                this.showRestoreModal = false;
+                this.backupList = [];
+            } else {
+                this.backupStatus = 'Restore failed';
+                alert('Restore failed: ' + result.error);
+            }
         }
     }));
 });
diff --git a/src/modules/github-backup.js b/src/modules/github-backup.js
new file mode 100644
index 0000000..c5e7d65
--- /dev/null
+++ b/src/modules/github-backup.js
@@ -0,0 +1,382 @@
+// GitHub Gists Auto-Backup Module
+// Handles automatic backup to GitHub Gists and restore functionality
+
+(function () {
+    const BACKUP_INTERVAL = 5 * 60 * 1000; // 5 minutes
+    let backupIntervalId = null;
+
+    const GitHubBackup = {
+        /**
+         * Validate GitHub token
+         */
+        async validateToken(token) {
+            try {
+                const response = await fetch('https://api.github.com/user', {
+                    headers: {
+                        'Authorization': `token ${token}`,
+                        'Accept': 'application/vnd.github.v3+json'
+                    }
+                });
+                if (response.ok) {
+                    const user = await response.json();
+                    return { valid: true, username: user.login };
+                }
+                return { valid: false, error: 'Invalid token' };
+            } catch (e) {
+                return { valid: false, error: e.message };
+            }
+        },
+
+        /**
+         * Export current project data as JSON
+         */
+        async exportProjectData(app) {
+            if (!app.currentProject) return null;
+
+            try {
+                const projectId = app.currentProject.id;
+
+                // Get all data for current project
+                const chapters = await db.chapters.where('projectId').equals(projectId).toArray();
+                const scenes = await db.scenes.where('projectId').equals(projectId).toArray();
+
+                // Get content for all scenes
+                const sceneContents = {};
+                for (const scene of scenes) {
+                    const content = await db.content.get(scene.id);
+                    sceneContents[scene.id] = content ? content.text : '';
+                }
+
+                // Get compendium entries (handle if table doesn't exist)
+                let compendium = [];
+                try {
+                    if (db.compendium) {
+                        compendium = await db.compendium.where('projectId').equals(projectId).toArray();
+                    }
+                } catch (e) {
+                    console.warn('Could not load compendium:', e);
+                }
+
+                // Get prompts (handle if table doesn't exist)
+                let prompts = [];
+                try {
+                    if (db.prompts) {
+                        prompts = await db.prompts.where('projectId').equals(projectId).toArray();
+                    }
+                } catch (e) {
+                    console.warn('Could not load prompts:', e);
+                }
+
+                return {
+                    version: '2.0',
+                    exportedAt: new Date().toISOString(),
+                    project: app.currentProject,
+                    chapters: chapters,
+                    scenes: scenes,
+                    sceneContents: sceneContents,
+                    compendium: compendium,
+                    prompts: prompts
+                };
+            } catch (e) {
+                console.error('Error exporting project data:', e);
+                return null;
+            }
+        },
+
+        /**
+         * Create or update GitHub Gist with backup
+         */
+        async backupToGist(app) {
+            if (!app.githubToken || !app.currentProject) {
+                return { success: false, error: 'No token or project' };
+            }
+
+            try {
+                const projectData = await this.exportProjectData(app);
+                if (!projectData) {
+                    return { success: false, error: 'No project data' };
+                }
+
+                const filename = `${app.currentProject.name.replace(/[^a-z0-9]/gi, '_')}_backup.json`;
+                const description = `Writingway Auto-Backup: ${app.currentProject.name}`;
+
+                // Check if gist already exists
+                const gistId = app.currentProjectGistId;
+
+                if (gistId) {
+                    // Update existing gist
+                    const response = await fetch(`https://api.github.com/gists/${gistId}`, {
+                        method: 'PATCH',
+                        headers: {
+                            'Authorization': `token ${app.githubToken}`,
+                            'Accept': 'application/vnd.github.v3+json',
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            description: description,
+                            files: {
+                                [filename]: {
+                                    content: JSON.stringify(projectData, null, 2)
+                                }
+                            }
+                        })
+                    });
+
+                    if (response.ok) {
+                        const data = await response.json();
+                        return {
+                            success: true,
+                            gistId: data.id,
+                            url: data.html_url,
+                            updated: true
+                        };
+                    }
+                }
+
+                // Create new gist
+                const response = await fetch('https://api.github.com/gists', {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `token ${app.githubToken}`,
+                        'Accept': 'application/vnd.github.v3+json',
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        description: description,
+                        public: false,
+                        files: {
+                            [filename]: {
+                                content: JSON.stringify(projectData, null, 2)
+                            }
+                        }
+                    })
+                });
+
+                if (response.ok) {
+                    const data = await response.json();
+                    return {
+                        success: true,
+                        gistId: data.id,
+                        url: data.html_url,
+                        created: true
+                    };
+                }
+
+                return { success: false, error: `HTTP ${response.status}` };
+            } catch (e) {
+                return { success: false, error: e.message };
+            }
+        },
+
+        /**
+         * List all backup versions from gist history
+         */
+        async listBackups(app) {
+            if (!app.githubToken || !app.currentProjectGistId) {
+                return { success: false, error: 'No token or gist ID' };
+            }
+
+            try {
+                // Get gist with full history
+                const response = await fetch(`https://api.github.com/gists/${app.currentProjectGistId}`, {
+                    headers: {
+                        'Authorization': `token ${app.githubToken}`,
+                        'Accept': 'application/vnd.github.v3+json'
+                    }
+                });
+
+                if (!response.ok) {
+                    return { success: false, error: `HTTP ${response.status}` };
+                }
+
+                const gist = await response.json();
+
+                // Get all versions
+                const versions = gist.history || [];
+
+                return {
+                    success: true,
+                    backups: versions.map(v => ({
+                        version: v.version,
+                        timestamp: v.committed_at,
+                        url: v.url,
+                        user: v.user ? v.user.login : 'unknown'
+                    }))
+                };
+            } catch (e) {
+                return { success: false, error: e.message };
+            }
+        },
+
+        /**
+         * Restore from a specific backup version
+         */
+        async restoreFromBackup(app, versionUrl) {
+            if (!app.githubToken) {
+                return { success: false, error: 'No token' };
+            }
+
+            try {
+                const response = await fetch(versionUrl, {
+                    headers: {
+                        'Authorization': `token ${app.githubToken}`,
+                        'Accept': 'application/vnd.github.v3+json'
+                    }
+                });
+
+                if (!response.ok) {
+                    return { success: false, error: `HTTP ${response.status}` };
+                }
+
+                const gistVersion = await response.json();
+                const files = gistVersion.files;
+                const firstFile = Object.values(files)[0];
+
+                if (!firstFile) {
+                    return { success: false, error: 'No backup data found' };
+                }
+
+                const backupData = JSON.parse(firstFile.content);
+
+                // Restore project data
+                await this.restoreProjectData(app, backupData);
+
+                return { success: true };
+            } catch (e) {
+                return { success: false, error: e.message };
+            }
+        },
+
+        /**
+         * Restore project data from backup
+         */
+        async restoreProjectData(app, backupData) {
+            const projectId = backupData.project.id;
+
+            // Update project info
+            await db.projects.put(backupData.project);
+
+            // Clear and restore chapters
+            await db.chapters.where('projectId').equals(projectId).delete();
+            for (const chapter of backupData.chapters) {
+                await db.chapters.add(chapter);
+            }
+
+            // Clear and restore scenes
+            await db.scenes.where('projectId').equals(projectId).delete();
+            for (const scene of backupData.scenes) {
+                await db.scenes.add(scene);
+            }
+
+            // Restore scene contents
+            for (const [sceneId, text] of Object.entries(backupData.sceneContents)) {
+                const wordCount = text ? text.trim().split(/\s+/).filter(w => w.length > 0).length : 0;
+                await db.content.put({
+                    sceneId: sceneId,
+                    text: text,
+                    wordCount: wordCount
+                });
+            }
+
+            // Clear and restore compendium
+            await db.compendium.where('projectId').equals(projectId).delete();
+            for (const entry of backupData.compendium || []) {
+                await db.compendium.add(entry);
+            }
+
+            // Clear and restore prompts
+            if (backupData.prompts) {
+                await db.prompts.where('projectId').equals(projectId).delete();
+                for (const prompt of backupData.prompts) {
+                    await db.prompts.add(prompt);
+                }
+            }
+
+            // Reload the project
+            await app.selectProject(projectId);
+        },
+
+        /**
+         * Start auto-backup timer
+         */
+        startAutoBackup(app) {
+            if (backupIntervalId) {
+                clearInterval(backupIntervalId);
+            }
+
+            backupIntervalId = setInterval(async () => {
+                if (app.backupEnabled && app.githubToken && app.currentProject) {
+                    app.backupStatus = 'Backing up...';
+                    const result = await this.backupToGist(app);
+
+                    if (result.success) {
+                        app.lastBackupTime = new Date();
+                        app.backupStatus = 'Backed up';
+                        if (result.gistId) {
+                            app.currentProjectGistId = result.gistId;
+                            this.saveBackupSettings(app);
+                        }
+                        console.log('✓ Auto-backup successful');
+                    } else {
+                        app.backupStatus = 'Backup failed';
+                        console.error('Auto-backup failed:', result.error);
+                    }
+                }
+            }, BACKUP_INTERVAL);
+        },
+
+        /**
+         * Stop auto-backup timer
+         */
+        stopAutoBackup() {
+            if (backupIntervalId) {
+                clearInterval(backupIntervalId);
+                backupIntervalId = null;
+            }
+        },
+
+        /**
+         * Save backup settings to localStorage
+         */
+        saveBackupSettings(app) {
+            try {
+                const settings = {
+                    enabled: app.backupEnabled,
+                    token: app.githubToken,
+                    gistId: app.currentProjectGistId,
+                    username: app.githubUsername
+                };
+                localStorage.setItem('writingway:backupSettings', JSON.stringify(settings));
+            } catch (e) {
+                console.error('Failed to save backup settings:', e);
+            }
+        },
+
+        /**
+         * Load backup settings from localStorage
+         */
+        loadBackupSettings(app) {
+            try {
+                const saved = localStorage.getItem('writingway:backupSettings');
+                if (saved) {
+                    const settings = JSON.parse(saved);
+                    app.backupEnabled = settings.enabled || false;
+                    app.githubToken = settings.token || '';
+                    app.currentProjectGistId = settings.gistId || '';
+                    app.githubUsername = settings.username || '';
+
+                    // Delay auto-backup start to avoid blocking initialization
+                    if (app.backupEnabled && app.githubToken) {
+                        setTimeout(() => {
+                            this.startAutoBackup(app);
+                        }, 5000); // Start after 5 seconds
+                    }
+                }
+            } catch (e) {
+                console.error('Failed to load backup settings:', e);
+            }
+        }
+    };
+
+    window.GitHubBackup = GitHubBackup;
+})();
diff --git a/src/update-checker.js b/src/update-checker.js
index 0dbd98c..87417bd 100644
--- a/src/update-checker.js
+++ b/src/update-checker.js
@@ -4,7 +4,7 @@
     const UpdateChecker = {
         // Build timestamp - update this when you push a new version
         // This represents when this version was created
-        buildDate: new Date('2025-11-17T01:10:00Z').getTime(), // Update before each push
+        buildDate: new Date('2025-11-17T01:40:00Z').getTime(), // Update before each push
 
         // GitHub repository info
         repoOwner: 'aomukai',