The most Purr-fect Image File Format for your AI workflows

Well- yes, but no, I'll come to that bit later, but before that, let me geek out about what this project is MEOW (Metadata Encoded Optimized Webfile) is a Python-based image file format designed to be efficient, practical, and cross-platform compatible. With support for RGBA transparency, metadata, and fast rendering capabilities, MEOW provides a modern alternative for image storage and manipulation. Whether you're a developer looking for a lightweight image format, an AI locked-in person to use the best possible file fomat, a digital artist needing transparent image support, or just a curious coder who wants a .meow file extension, MEOW offers a simple yet powerful solution.

The First image to ever be converted to .meow Note: GitHub doesn't support .meow files (YET), so had to display the original PNG source

MEOW started off as just a fun, new (very ineffecient) image file format I made studying about them as a meme while having better metadata to be used with AI, but I realised something.

People don't make new file formats simply because of one problem- they're very hard to bring to mass adoption, what if we fix that?

MEOW uses a steganographic image format that embeds rich AI metadata while maintaining PNG compatibility. It's basically PNGs on Steroids.

📱 Standard Viewer (Setup Required)
   ↓ Method 1: Rename test.meow → test.png
   ↓ Method 2: Run file association script
🖼️ Result: Opens as beautiful PNG image

🤖 AI-Aware App  
   ↓ Opens .meow file directly (or renamed .png)
🧠 Sees: Image + Rich AI metadata

MEOW is specifically designed for use with AI, embedding metadata that accelerates machine learning workflows and enhances LLM image understanding:

MEOW doesn't just store metadata - it embeds AI-specific intelligence that traditional formats can't handle. When any image is converted to a .meow, this data is automatically added in the conversion process:

1. Pre-computed AI Features

• Optimal preprocessing parameters embedded in the file
• Attention maps showing where AI models should focus
• Bounding boxes and object detection data
• Saliency regions for computer vision tasks

2. Model Optimization Data

3. Steganographic Storage

Unlike traditional metadata that's easily lost:

• Encoded in pixel LSBs (Least Significant Bits)
• Survives file operations that would strip normal metadata
• Invisible to standard viewers but accessible to AI applications

MEOW uses LSB (Least Significant Bit) steganography to hide AI data inside standard PNG images:

Original Pixel: [R, G, B, A]
                [142, 87, 203, 255]

After Hiding Data:
                [R, G, B, A]  
                [140, 84, 200, 255]
                 ↑    ↑    ↑
            Changed by 2 bits max
            (Visually imperceptible)

PNG Header + Image Data
    ↓ (hidden in LSBs)
[MEOW_STEG_V2][Size][Compressed AI Data]

The Problem: AI-enhanced formats typically sacrifice compatibility for features
The Solution: Hide AI data inside universally-compatible PNG files
The Result: Best of both worlds - works everywhere + AI superpowers

⚠️ Important: While MEOW files contain standard PNG data, you need either:

1. Rename .meow → .png (compatibility for viewing), OR
2. Run file association scripts (one-time setup to make .meow extension recognized)

Without setup, most viewers won't recognize the .meow extension by default. Because well, I just made it lol.

# Clone the repository
git clone https://github.com/kuberwastaken/MEOW-FILES.git

# Navigate to the directory
cd MEOW-FILES

# Install dependencies
pip install -r requirements.txt

# Set up file associations (optional)
windows\associate_meow.bat  # Run as administrator

# Convert any image to steganographic MEOW
python meow_format.py image.jpg output.meow

# Convert PNG with rich AI annotations
python convert.py image.png enhanced.meow

# Launch the MEOW GUI with AI features
python meow_gui.py

# Option 1: Rename to .png (works instantly everywhere)
rename test.meow test.png
start test.png                    # Opens in default viewer

# Option 2: Set up file associations (makes .meow recognized)
windows\associate_meow.bat        # Run as administrator first
start test.meow                   # Now opens directly!

# Launch MEOW viewer to see hidden AI metadata
python meow_gui.py

# Run compatibility demonstration
python final_demonstration.py

# 1. Create a steganographic MEOW file
python meow_format.py "photo.jpg" "photo.meow"

# 2. Test universal compatibility - Choose your method:

# Method A: Rename to PNG (instant compatibility)
copy photo.meow photo.png          # Keep original + create PNG copy
start photo.png                    # Opens in any image viewer!

# Method B: File association setup (one-time setup)
windows\associate_meow.bat         # Run as admin (one-time setup)
start photo.meow                   # Now .meow files open directly!

# 3. Extract AI data (MEOW-aware apps see hidden metadata)
python meow_gui.py                 # Load .meow OR renamed .png - AI data intact!

To make .meow files open directly in your system's default image viewer, run the appropriate setup script for your platform:

# Run as administrator to set up file associations
windows\associate_meow.bat

# Make executable and run
chmod +x macos/associate_meow_macos.sh
./macos/associate_meow_macos.sh

# Universal setup script that detects your OS
chmod +x scripts/associate_meow_crossplatform.sh
./scripts/associate_meow_crossplatform.sh

After running the appropriate script, double-clicking any .meow file will open it in your system's default image viewer (Paint, Preview, etc.) while preserving the hidden AI metadata for MEOW-aware applications.

Note: File association is optional - you can always rename .meow files to .png for instant compatibility with any image viewer.

📁 MEOW File Structure:
┌─────────────────────┐
│    PNG Header       │ ← Standard PNG
│                     │
│  RGB Image Data     │ ← Normal pixels +
│  (with hidden data) │   hidden AI data
│                     │   in 2 LSBs
│  PNG Footer         │ ← Standard PNG
└─────────────────────┘

🔬 Pixel-Level Storage:
Original: R[142] G[87] B[203]
Binary:   10001110 01010111 11001011

After:    R[140] G[84] B[200] 
Binary:   10001100 01010100 11001000
                ↑↑       ↑↑       ↑↑
            Hidden data bits

{
  "version": 2,
  "features": {
    "brightness": 126.642,
    "contrast": 67.335, 
    "edge_density": 0.738,
    "mean_rgb": [126.69, 126.6, 126.64],
    "dimensions": [400, 300]
  },
  "attention_maps": {
    "avg_attention": 117.86,
    "max_attention": 255,
    "attention_peaks": 12,
    "focus_regions": [[120, 80], [250, 150]]
  },
  "ai_annotations": {
    "object_classes": ["cat", "background"],
    "bounding_boxes": [...],
    "preprocessing_params": {
      "mean_rgb": [0.485, 0.456, 0.406],
      "input_size": [224, 224],
      "normalization": "imagenet"
    },
    "llm_context": {
      "scene_description": "A domestic cat sitting on wooden surface",
      "visual_elements": ["furry texture", "natural lighting", "indoor setting"],
      "suggested_tags": ["pet", "animal", "indoor", "portrait"]
    }
  },
  "model_hints": {
    "recommended_models": ["ResNet50", "CLIP", "YOLO"],
    "complexity_score": 0.73,
    "processing_priority": "high_detail"
  }
}

• Built with Python 3.6+
• Uses Pillow/PIL for image processing
• NumPy for efficient steganographic operations
• zlib for AI metadata compression
• tkinter for cross-platform GUI
• JSON for structured AI data storage

• AI Training Datasets: Embedded annotations eliminate separate metadata files
• Computer Vision: Pre-computed features accelerate model inference
• Digital Asset Management: Rich metadata without database dependency
• Research Archives: Self-documenting images with analysis results
• Production Workflows: Integration with existing tools (after setup or rename to .png)
• LLM Vision Tasks: Enhanced multimodal AI with embedded context
• Automated Content Analysis: Self-describing images for content pipelines
• AI Model Training: Consistent, portable annotations across platforms

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Initial idea inspired by FaceDev, whose BRUHIFF format provided a creative starting point.

This project is released under the Apache 2.0 License. See the LICENSE file for details.