Upload 4 files

DEPLOYMENT_INSTRUCTIONS.md

@@ -0,0 +1,208 @@
+# LUXBIN - Hugging Face Deployment Instructions
+
+## 📋 Complete Deployment Guide
+
+Follow these steps to deploy your LUXBIN demo to Hugging Face Spaces.
+
+---
+
+## Prerequisites
+
+1. **Hugging Face Account**: Create one at [huggingface.co](https://huggingface.co)
+2. **Git Installed**: For uploading files (or use the web interface)
+
+---
+
+## Method 1: Web Upload (Easiest)
+
+### Step 1: Create New Space
+
+1. Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Click **"Create new Space"**
+3. Fill in:
+   - **Space name**: `luxbin-demo` (or your preferred name)
+   - **License**: `mit` or `apache-2.0`
+   - **SDK**: Select **Gradio**
+   - **Space hardware**: `CPU basic` (free tier works fine)
+4. Click **"Create Space"**
+
+### Step 2: Upload Files
+
+You'll see an empty repository. Upload these 3 files:
+
+**File 1: `app.py`**
+- Click **"Files and versions"** → **"Add file"** → **"Upload files"**
+- Upload: `/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO/app.py`
+
+**File 2: `requirements.txt`**
+- Click **"Add file"** → **"Upload files"** again
+- Upload: `/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO/requirements.txt`
+
+**File 3: `README.md`**
+- The README.md is auto-created, but replace it with:
+- Click on `README.md` → **"Edit"**
+- Copy contents from `/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO/README.md`
+- Click **"Commit changes to main"**
+
+### Step 3: Wait for Build
+
+- Hugging Face will automatically build your Space
+- Watch the build logs at the top of the page
+- Should take 1-2 minutes
+- When you see **"Running"** status, it's live!
+
+### Step 4: Test
+
+1. Visit your Space URL: `https://huggingface.co/spaces/YOUR_USERNAME/luxbin-demo`
+2. Try the encoder with "HELLO WORLD"
+3. Test different grammar settings
+4. View the alphabet wheel and grammar guide
+
+---
+
+## Method 2: Git Upload (Advanced)
+
+### Step 1: Create Space
+
+Same as Method 1 - create the Space on Hugging Face website first.
+
+### Step 2: Clone Repository
+
+```bash
+cd ~/Desktop
+git clone https://huggingface.co/spaces/YOUR_USERNAME/luxbin-demo
+cd luxbin-demo
+```
+
+### Step 3: Copy Files
+
+```bash
+cp "/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO/app.py" .
+cp "/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO/requirements.txt" .
+cp "/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO/README.md" .
+```
+
+### Step 4: Push to Hugging Face
+
+```bash
+git add .
+git commit -m "Initial LUXBIN demo"
+git push
+```
+
+### Step 5: Verify
+
+Visit your Space URL and test the app.
+
+---
+
+## Troubleshooting
+
+### Build Fails with Gradio Import Error
+
+**Error**: `ImportError: cannot import name 'HfFolder' from 'huggingface_hub'`
+
+**Fix**: Make sure `requirements.txt` has:
+```txt
+gradio>=5.9.1
+huggingface-hub>=1.2.0
+```
+
+**NOT**:
+```txt
+gradio==4.44.1  ❌ (too old)
+```
+
+### Font Not Found Warnings
+
+**Warning**: `Cannot open font resource`
+
+**Impact**: Letters on hue wheel may not display perfectly, but app still works
+
+**Fix** (optional): Add to `requirements.txt`:
+```txt
+matplotlib>=3.7.0
+```
+
+And update font path in `app.py`:
+```python
+try:
+    font = ImageFont.truetype("DejaVuSans.ttf", 16)
+except:
+    font = ImageFont.load_default()
+```
+
+### Space Shows "Building" Forever
+
+1. Check build logs for errors
+2. Most common: requirements.txt syntax error
+3. Fix: Make sure each package is on its own line, no trailing spaces
+
+---
+
+## Updating Your Space
+
+### Web Method:
+1. Go to your Space
+2. Click **"Files and versions"**
+3. Click on the file you want to edit
+4. Make changes
+5. Click **"Commit changes to main"**
+
+### Git Method:
+```bash
+cd luxbin-demo
+# Make your changes to app.py or other files
+git add .
+git commit -m "Updated encoder logic"
+git push
+```
+
+Space will automatically rebuild!
+
+---
+
+## Making Your Space Public
+
+By default, Spaces are public. To change visibility:
+
+1. Go to your Space settings
+2. Scroll to **"Visibility"**
+3. Choose **"Public"** or **"Private"**
+
+---
+
+## Sharing Your Space
+
+Your Space URL is:
+```
+https://huggingface.co/spaces/YOUR_USERNAME/luxbin-demo
+```
+
+Share this link! People can:
+- Use the encoder without signing in
+- See your README documentation
+- Fork your Space to make their own version
+
+---
+
+## Next Steps
+
+1. **Customize**: Add more LUXBIN features (decoder, animations, sound)
+2. **Document**: Add examples and tutorials to README
+3. **Share**: Post on social media, forums, etc.
+4. **Improve**: Add temporal encoding visualization, sentence structure, etc.
+
+---
+
+## Support
+
+- **Hugging Face Docs**: [huggingface.co/docs/hub/spaces](https://huggingface.co/docs/hub/spaces)
+- **Gradio Docs**: [gradio.app/docs](https://www.gradio.app/docs)
+- **LUXBIN Spec**: See `README.md` in this demo
+
+---
+
+**Your LUXBIN demo is ready to deploy!** 🚀
+
+Choose Method 1 (web upload) for simplicity, or Method 2 (git) if you're comfortable with command line.

GITHUB_SETUP.md

@@ -0,0 +1,144 @@
+# GitHub Repository Setup for LUXBIN
+
+## ✅ Git Initialized & Ready
+
+Your local git repository is ready with a clean commit!
+
+**Important**: LUXBIN is a separate project from QuantumGameDevAI, so it needs its own repository.
+
+---
+
+## 🎯 Create New GitHub Repository for LUXBIN
+
+### Step 1: Create Repository on GitHub
+
+1. Go to [github.com/new](https://github.com/new)
+2. Fill in:
+   - **Repository name**: `LUXBIN-Demo` (or `luxbin-photonic-language`)
+   - **Description**: `⚛️ Photonic Binary Language - Colors are letters, shades are grammar`
+   - **Visibility**: ✅ **Public** (recommended for sharing)
+   - **Important**: ❌ **DON'T** initialize with README, .gitignore, or license
+3. Click **"Create repository"**
+
+### Step 2: Push Your Code
+
+After creating the empty repo, run these commands:
+
+```bash
+cd "/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO"
+
+# Add your new GitHub repo as remote (replace YOUR_USERNAME)
+git remote add origin https://github.com/YOUR_USERNAME/LUXBIN-Demo.git
+
+# Push to GitHub
+git branch -M main
+git push -u origin main
+```
+
+**Example** (if your username is "nichechristie"):
+```bash
+git remote add origin https://github.com/nichechristie/LUXBIN-Demo.git
+git branch -M main
+git push -u origin main
+```
+
+---
+
+## ✨ What's Included
+
+Your repository contains:
+
+```
+LUXBIN_HF_DEMO/
+├── app.py                        # Complete Gradio demo app
+├── requirements.txt              # Python dependencies (Gradio 5.9.1+)
+├── README.md                     # Hugging Face Space documentation
+├── DEPLOYMENT_INSTRUCTIONS.md    # HF deployment guide
+├── GITHUB_SETUP.md              # This file
+└── .gitignore                   # Git ignore patterns
+
+✅ Commit: "Initial commit - LUXBIN Photonic Binary Language Demo"
+```
+
+---
+
+## 🚀 After Pushing to GitHub
+
+### Option 1: Deploy to Hugging Face from GitHub (Easiest)
+
+1. Go to [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Click **"Import from GitHub"**
+3. Select your `LUXBIN-Demo` repository
+4. Hugging Face automatically:
+   - Reads `README.md` for the Space card
+   - Installs packages from `requirements.txt`
+   - Runs `app.py` as the Gradio app
+5. Your demo goes live in 1-2 minutes! ✨
+
+### Option 2: Manual Hugging Face Upload
+
+Follow the detailed instructions in `DEPLOYMENT_INSTRUCTIONS.md`
+
+---
+
+## 📊 Repository Description
+
+For your GitHub repo, add this description:
+
+```
+⚛️ LUXBIN - Photonic Binary Language where colors are letters and shades are grammar.
+Interactive Gradio demo for encoding text into photonic color sequences using HSL color space.
+```
+
+### Suggested Topics
+
+Add these topics to your GitHub repo for discoverability:
+
+- `photonics`
+- `language`
+- `gradio`
+- `huggingface-spaces`
+- `color-theory`
+- `hsl-color`
+- `binary`
+- `communication`
+- `python`
+- `demo`
+
+---
+
+## 🔄 Future Updates
+
+When you make changes:
+
+```bash
+cd "/Users/nicholechristie/Documents/Unreal Projects/WWYD 5.7/LUXBIN_HF_DEMO"
+
+# Make your changes to files...
+
+git add .
+git commit -m "Description of changes"
+git push
+```
+
+If you connected GitHub to Hugging Face, the Space auto-updates!
+
+---
+
+## 🎯 Two Separate Projects
+
+You now have:
+
+1. **QuantumGameDevAI** - AI-powered game development toolkit
+   - Repo: `github.com/nichechristie/QuantumGameDevAI`
+
+2. **LUXBIN-Demo** - Photonic binary language demo
+   - Repo: `github.com/YOUR_USERNAME/LUXBIN-Demo` (create this now)
+
+Keep them separate for better organization!
+
+---
+
+**Create the new LUXBIN GitHub repository and push your code!** 🎨⚛️
+
+Run the commands in Step 2 after creating the repo.

README.md

@@ -0,0 +1,62 @@
+---
+title: LUXBIN - Photonic Binary Language
+emoji: ⚛️
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# ⚛️ LUXBIN - Photonic Binary Language
+
+**A language where colors are letters and shades are grammar**
+
+## What is LUXBIN?
+
+LUXBIN is a photonic binary language where semantic information is encoded directly in the physical properties of light. Instead of using traditional text or binary digits, LUXBIN uses color and light to communicate.
+
+### Key Concepts
+
+- **Hue (0°-360°)** = Letter identity (A-Z)
+- **Saturation** = Part of speech (Noun, Verb, Adjective, etc.)
+- **Lightness** = Tense/mode (Present, Past, Future, Conditional)
+- **Timing** = Word and sentence boundaries
+
+### How It Works
+
+1. **26 Letters**: A-Z are mapped to hue values from 0° to 140.625° in 5.625° steps
+2. **Grammar Encoding**: Saturation and lightness encode grammatical information
+3. **Visual Output**: Text is converted to a sequence of colored blocks
+4. **Binary Foundation**: 6-bit indexing (64 total symbols possible)
+
+## Features
+
+This demo lets you:
+
+- 📤 **Encode Text**: Convert any text into LUXBIN color sequences
+- 🎨 **Visual Alphabet**: See the complete hue wheel with all 26 letters
+- 📚 **Grammar Guide**: Understand how saturation and lightness encode grammar
+- ℹ️ **Learn More**: Explore the complete LUXBIN specification
+
+## Applications
+
+- **Assistive Technology**: Non-verbal communication
+- **Secure Communication**: Line-of-sight only, hard to intercept
+- **Extreme Environments**: Underwater, space, RF-denied zones
+- **Human-Machine Interfaces**: Direct photonic signaling
+
+## Technical Details
+
+- **Alphabet Size**: 26 letters + 38 extended symbols (64 total)
+- **Color Space**: HSL (Hue, Saturation, Lightness)
+- **Binary Base**: 6-bit indexing
+- **Temporal Encoding**: 100ms/letter, 200ms/word, 500ms/sentence
+
+## Created By
+
+**Nicholechristie** - Open Specification Language
+
+## Try It
+
+Use the encoder tab to convert text like "HELLO WORLD" into photonic sequences and see how grammar affects the colors!

app.py

@@ -0,0 +1,397 @@
+"""
+LUXBIN - Photonic Binary Language Demo
+A language where colors are letters and shades are grammar
+"""
+
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import time
+
+# LUXBIN Alphabet (26 letters A-Z)
+ALPHABET = {
+    'A': 0.0, 'B': 5.625, 'C': 11.25, 'D': 16.875, 'E': 22.5,
+    'F': 28.125, 'G': 33.75, 'H': 39.375, 'I': 45.0, 'J': 50.625,
+    'K': 56.25, 'L': 61.875, 'M': 67.5, 'N': 73.125, 'O': 78.75,
+    'P': 84.375, 'Q': 90.0, 'R': 95.625, 'S': 101.25, 'T': 106.875,
+    'U': 112.5, 'V': 118.125, 'W': 123.75, 'X': 129.375, 'Y': 135.0,
+    'Z': 140.625
+}
+
+# Reverse mapping
+REVERSE_ALPHABET = {v: k for k, v in ALPHABET.items()}
+
+# Grammar mappings
+PARTS_OF_SPEECH = {
+    'Noun': 100,
+    'Verb': 75,
+    'Adjective': 50,
+    'Modifier': 30,
+    'Control': 0
+}
+
+TENSES = {
+    'Present': 70,
+    'Past': 40,
+    'Future': 85,
+    'Conditional': 90
+}
+
+
+def hsl_to_rgb(h, s, l):
+    """Convert HSL to RGB (0-255)"""
+    s = s / 100.0
+    l = l / 100.0
+
+    c = (1 - abs(2 * l - 1)) * s
+    x = c * (1 - abs((h / 60) % 2 - 1))
+    m = l - c / 2
+
+    if h < 60:
+        r, g, b = c, x, 0
+    elif h < 120:
+        r, g, b = x, c, 0
+    elif h < 180:
+        r, g, b = 0, c, x
+    elif h < 240:
+        r, g, b = 0, x, c
+    elif h < 300:
+        r, g, b = x, 0, c
+    else:
+        r, g, b = c, 0, x
+
+    return int((r + m) * 255), int((g + m) * 255), int((b + m) * 255)
+
+
+def encode_text_to_luxbin(text, part_of_speech='Noun', tense='Present'):
+    """Encode text to LUXBIN color sequence"""
+    text = text.upper()
+    saturation = PARTS_OF_SPEECH.get(part_of_speech, 100)
+    lightness = TENSES.get(tense, 70)
+
+    colors = []
+    for char in text:
+        if char == ' ':
+            colors.append((0, 0, 0))  # Black for space
+        elif char in ALPHABET:
+            hue = ALPHABET[char]
+            rgb = hsl_to_rgb(hue, saturation, lightness)
+            colors.append(rgb)
+        else:
+            colors.append((128, 128, 128))  # Gray for unknown
+
+    return colors
+
+
+def create_color_strip(colors, width=800, height=100):
+    """Create image showing color sequence"""
+    if not colors:
+        return Image.new('RGB', (width, height), 'black')
+
+    img = Image.new('RGB', (width, height))
+    draw = ImageDraw.Draw(img)
+
+    block_width = width // len(colors)
+
+    for i, color in enumerate(colors):
+        x1 = i * block_width
+        x2 = x1 + block_width
+        draw.rectangle([x1, 0, x2, height], fill=color)
+
+    return img
+
+
+def create_hue_wheel(size=400):
+    """Create visual hue wheel showing alphabet"""
+    img = Image.new('RGB', (size, size), 'white')
+    draw = ImageDraw.Draw(img)
+
+    center = size // 2
+    radius = size // 2 - 20
+
+    # Draw color wheel
+    for i in range(360):
+        angle = i * np.pi / 180
+        hue = i
+        rgb = hsl_to_rgb(hue, 100, 70)
+
+        x1 = center + int((radius - 30) * np.cos(angle))
+        y1 = center + int((radius - 30) * np.sin(angle))
+        x2 = center + int(radius * np.cos(angle))
+        y2 = center + int(radius * np.sin(angle))
+
+        draw.line([x1, y1, x2, y2], fill=rgb, width=2)
+
+    # Add letter labels
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
+    except:
+        font = ImageFont.load_default()
+
+    for letter, hue in ALPHABET.items():
+        angle = (hue - 90) * np.pi / 180  # Adjust for top = 0°
+        label_radius = radius + 30
+        x = center + int(label_radius * np.cos(angle))
+        y = center + int(label_radius * np.sin(angle))
+
+        # Draw letter
+        bbox = draw.textbbox((x, y), letter, font=font)
+        draw.text((x - (bbox[2] - bbox[0]) / 2, y - (bbox[3] - bbox[1]) / 2),
+                  letter, fill='black', font=font)
+
+    return img
+
+
+def encode_demo(text, pos, tense):
+    """Main encoding function"""
+    colors = encode_text_to_luxbin(text, pos, tense)
+    strip = create_color_strip(colors)
+
+    # Create description
+    desc = f"**LUXBIN Encoding**\n\n"
+    desc += f"Text: `{text}`\n\n"
+    desc += f"Grammar: {pos} (Saturation: {PARTS_OF_SPEECH[pos]}%), "
+    desc += f"{tense} (Lightness: {TENSES[tense]}%)\n\n"
+    desc += f"**Color Sequence:** {len(colors)} symbols\n\n"
+
+    # List each letter with its color
+    for i, char in enumerate(text.upper()):
+        if char == ' ':
+            desc += "` ` → Black (word boundary)\n\n"
+        elif char in ALPHABET:
+            desc += f"`{char}` → Hue {ALPHABET[char]:.1f}° (RGB: {colors[i]})\n\n"
+
+    return strip, desc
+
+
+def create_grammar_guide():
+    """Create visual guide for grammar rules"""
+    img = Image.new('RGB', (600, 400), 'white')
+    draw = ImageDraw.Draw(img)
+
+    try:
+        font_title = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 20)
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 14)
+    except:
+        font_title = font = ImageFont.load_default()
+
+    y = 20
+
+    # Title
+    draw.text((20, y), "LUXBIN Grammar Rules", fill='black', font=font_title)
+    y += 40
+
+    # Saturation (Parts of Speech)
+    draw.text((20, y), "Saturation → Part of Speech", fill='black', font=font)
+    y += 30
+
+    for pos, sat in PARTS_OF_SPEECH.items():
+        rgb = hsl_to_rgb(180, sat, 70)  # Use cyan hue for demo
+        draw.rectangle([20, y, 70, y + 20], fill=rgb, outline='black')
+        draw.text((80, y + 3), f"{pos}: {sat}%", fill='black', font=font)
+        y += 30
+
+    y += 20
+
+    # Lightness (Tense)
+    draw.text((20, y), "Lightness → Tense/Mode", fill='black', font=font)
+    y += 30
+
+    for tense, light in TENSES.items():
+        rgb = hsl_to_rgb(180, 100, light)  # Use cyan hue for demo
+        draw.rectangle([20, y, 70, y + 20], fill=rgb, outline='black')
+        draw.text((80, y + 3), f"{tense}: {light}%", fill='black', font=font)
+        y += 30
+
+    return img
+
+
+# Create Gradio interface
+with gr.Blocks(title="LUXBIN - Photonic Binary Language", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # ⚛️ LUXBIN - Photonic Binary Language
+
+    **A language where colors are letters and shades are grammar**
+
+    - **Hue (0°-360°)** = Letter identity (A-Z)
+    - **Saturation** = Part of speech (Noun, Verb, etc.)
+    - **Lightness** = Tense/mode (Present, Past, etc.)
+    - **Timing** = Word and sentence boundaries
+
+    ---
+    """)
+
+    with gr.Tabs():
+        # Tab 1: Encoder
+        with gr.Tab("📤 Encode Text to LUXBIN"):
+            gr.Markdown("### Convert text into photonic color sequences")
+
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter Text",
+                        placeholder="HELLO WORLD",
+                        value="HELLO"
+                    )
+
+                    pos_input = gr.Dropdown(
+                        choices=list(PARTS_OF_SPEECH.keys()),
+                        value="Noun",
+                        label="Part of Speech (Saturation)"
+                    )
+
+                    tense_input = gr.Dropdown(
+                        choices=list(TENSES.keys()),
+                        value="Present",
+                        label="Tense/Mode (Lightness)"
+                    )
+
+                    encode_btn = gr.Button("🎨 Encode to LUXBIN", variant="primary")
+
+                with gr.Column():
+                    color_output = gr.Image(label="LUXBIN Color Sequence")
+                    desc_output = gr.Markdown()
+
+            encode_btn.click(
+                fn=encode_demo,
+                inputs=[text_input, pos_input, tense_input],
+                outputs=[color_output, desc_output]
+            )
+
+            gr.Markdown("""
+            **How to read:**
+            - Each color block = one letter
+            - Black = space (word boundary)
+            - Hue = which letter (A-Z)
+            - Saturation = grammatical role
+            - Lightness = tense
+            """)
+
+        # Tab 2: Alphabet Reference
+        with gr.Tab("🎨 Alphabet & Hue Wheel"):
+            gr.Markdown("### Visual reference for the LUXBIN alphabet")
+
+            wheel_img = create_hue_wheel()
+            gr.Image(value=wheel_img, label="LUXBIN Hue Wheel (26 Letters)")
+
+            gr.Markdown("""
+            **How it works:**
+            - 360° hue spectrum divided into 64 symbols
+            - A-Z occupy first 26 positions
+            - Step size: 5.625° per symbol
+            - A = 0° (red), Z = 140.625° (greenish-blue)
+            """)
+
+            # Show alphabet table
+            gr.Markdown("### Complete Alphabet")
+
+            alphabet_html = "<table style='width:100%'><tr>"
+            for i, (letter, hue) in enumerate(ALPHABET.items()):
+                if i % 6 == 0 and i > 0:
+                    alphabet_html += "</tr><tr>"
+                rgb = hsl_to_rgb(hue, 100, 70)
+                alphabet_html += f"<td style='background-color:rgb{rgb}; padding:10px; text-align:center; border:1px solid black;'><b>{letter}</b><br>{hue:.1f}°</td>"
+            alphabet_html += "</tr></table>"
+
+            gr.HTML(alphabet_html)
+
+        # Tab 3: Grammar Guide
+        with gr.Tab("📚 Grammar Rules"):
+            gr.Markdown("### LUXBIN grammar encoded in light properties")
+
+            grammar_img = create_grammar_guide()
+            gr.Image(value=grammar_img, label="Grammar Visual Guide")
+
+            gr.Markdown("""
+            ### Encoding Rules
+
+            **Binary Layer:**
+            - Each symbol = 6 bits (0-63)
+            - Binary indexes photonic states
+            - Not direct letter encoding
+
+            **Photonic Layer:**
+            - Hue = semantic identity (which letter/symbol)
+            - Saturation = grammatical role
+            - Lightness = temporal/modal information
+
+            **Temporal Layer:**
+            - 100ms = letter duration
+            - 200ms dark = word boundary
+            - 500ms dark = sentence end
+
+            **Modifiers:**
+            - +10% darker = plural
+            - -10% lighter = negation
+            - Rapid flicker = emphasis
+            - Smooth fade = completion
+            """)
+
+        # Tab 4: About
+        with gr.Tab("ℹ️ About LUXBIN"):
+            gr.Markdown("""
+            # About LUXBIN
+
+            **LUXBIN** is a photonic binary language where semantic information is encoded directly in the physical properties of light.
+
+            ## Key Concepts
+
+            1. **Physics as Syntax**: Light parameters carry meaning
+            2. **Parallel Channels**: Multiple layers of information in one photon
+            3. **Non-Linear Encoding**: Not a cipher, but a genuine language
+
+            ## Applications
+
+            - **Assistive Technology**: Non-verbal communication
+            - **Secure Communication**: Line-of-sight only, hard to intercept
+            - **Extreme Environments**: Underwater, space, RF-denied zones
+            - **Human-Machine Interfaces**: Direct photonic signaling
+
+            ## Technical Details
+
+            - **Alphabet Size**: 26 letters + 38 extended symbols
+            - **Color Space**: HSL (Hue, Saturation, Lightness)
+            - **Binary Base**: 6-bit indexing (64 total symbols)
+            - **Grammar Layers**: Saturation, Lightness, Temporal
+
+            ## Implementation
+
+            - **Hardware**: ESP32 + WS2812 RGB LEDs
+            - **Software**: Python encoder/decoder
+            - **Perception**: Trainable by humans in ~30 minutes
+
+            ## Status
+
+            LUXBIN is a complete language specification ready for:
+            - Hardware prototyping
+            - Human perception testing
+            - Standardization
+            - Publication
+
+            ---
+
+            **Created by:** Nicholechristie
+            **Version:** 1.0
+            **License:** Open Specification
+            """)
+
+    # Examples
+    gr.Markdown("---")
+    gr.Markdown("### 🚀 Try These Examples")
+
+    gr.Examples(
+        examples=[
+            ["HELLO WORLD", "Noun", "Present"],
+            ["TEST", "Verb", "Past"],
+            ["AI LANGUAGE", "Noun", "Future"],
+            ["QUANTUM", "Adjective", "Present"],
+        ],
+        inputs=[text_input, pos_input, tense_input],
+        outputs=[color_output, desc_output],
+        fn=encode_demo,
+        cache_examples=True
+    )
+
+# Launch
+if __name__ == "__main__":
+    demo.launch()