Getting Started: Your First Vault in 10 Minutes

A complete beginner's guide to Gameframe

Read Time: 15 minutes

§Introduction: Why You're Here#

You're probably here because you're tired of the chaos. Design documents scattered across Google Drive. Balance spreadsheets with names like "final_v3_ACTUALLY_FINAL.csv". That moment in a meeting when someone asks "wait, is this the current version?" and nobody knows.

Gameframe fixes this. It's version control for game design—the same concept that revolutionized software development, now built specifically for design documents, balance data, and game production workflows.

This guide will take you from zero to productive in about 15 minutes. By the end, you'll understand not just *how* to use Gameframe, but *why* it works the way it does.

§What You'll Learn#

By the end of this guide, you'll have:

• —Created your first vault (your project's home base)
• —Uploaded and organized your first documents
• —Made edits and seen how version history actually works
• —Compared two versions side-by-side (the "aha!" moment)
• —Understood why this changes everything for your team

Let's get started.

§Part 1: Setting Up Your Account#

Creating Your Account#

Head to getgameframe.com and click "Join the Beta". You have three options:

• —Email signup - Classic username/password
• —Google - One-click if you use Google Workspace
• —GitHub - Popular with technical teams

Pro tip: Use your work email. When you invite teammates later, having matching domains makes permissions easier.

Your First Login#

After signing up, you'll land on your dashboard. Take a moment to look around:

What you're seeing:

• —Left sidebar - Navigation to all your vaults and features
• —Main area - Currently empty, waiting for your first vault
• —Top bar - Search, notifications, and your profile

The interface is intentionally minimal. No clutter, no learning curve, no "where do I click?" moments.

Quick Settings to Configure#

Before diving in, hit Settings (gear icon) and configure:

• —Display name - How teammates will see you
• —Notification preferences - Email alerts for changes, comments, etc.
• —Theme - Light or dark mode (we support both)

§Part 2: Creating Your First Vault#

What Is a Vault?#

Think of a vault as a supercharged project folder. It's where all documents for one game/project live. But unlike a regular folder:

• —Every change is tracked automatically
• —You can branch documents to experiment safely
• —AI extracts entities (characters, items, mechanics) for cross-referencing
• —Role-based permissions control who sees what

One vault per project is the recommended setup. If you're working on multiple games, create multiple vaults.

Step-by-Step: Creating a Vault#

1. 1.Click "New Vault" in the left sidebar (or the big "Create Your First Vault" button)
2. 2.Name it clearly - "Project Nebula", "Untitled Roguelike", "Mobile Game 2025"
3. 3.Add a description - "Our sci-fi RPG with turn-based combat" (helps teammates understand context)
4. 4.Choose visibility - Private (default) or Team (if you've set up an organization)
5. 5.Click Create

Naming advice: Be specific. "Game Project" is bad. "Starfall RPG - Steam Release" is good. You'll thank yourself when you have multiple vaults.

Your Empty Vault#

You now have an empty vault. The interface shows:

• —Documents tab - Where your files will live
• —Versions tab - Global version history across all docs
• —Branches tab - For experimental work (more on this later)
• —Team tab - Manage who has access
• —Settings - Vault-specific configuration

Time to add some content.

§Part 3: Uploading Your First Document#

Supported File Types#

Gameframe handles the files game teams actually use:

Why these formats? They're text-based, which means we can show you exactly what changed line-by-line. Binary formats (Word, PDF) can be stored but not diffed.

Uploading: Three Methods#

Method 1: Drag and Drop

Simply drag a file from your computer into the document area. This is the fastest way.

Method 2: Upload Button

Click "Upload Document" and browse to your file.

Method 3: Create New

Click "New Document" to create a blank markdown file directly in Gameframe.

What Happens When You Upload#

When you upload a file, Gameframe does several things:

1. 1.Stores the content - Your file is saved securely
2. 2.Creates version 1 - The initial version is recorded
3. 3.Extracts entities - AI scans for characters, items, abilities, mechanics
4. 4.Indexes for search - Content becomes instantly searchable
5. 5.Records metadata - File type, size, upload time, uploader

Your First Upload: Try This#

Create a simple markdown file called player_stats.md:

# Player Statistics

## Base Stats
- Health: 100
- Mana: 50
- Stamina: 75

## Classes
### Warrior
- Bonus Health: +50
- Starting Weapon: Iron Sword

### Mage
- Bonus Mana: +30
- Starting Weapon: Oak Staff

Upload this file. You'll see it appear in your documents list with a green "v1" badge.

§Part 4: Viewing and Understanding Your Document#

The Document View#

Click on your uploaded document. The view has several components:

Main content area:

• —Rendered markdown (headers, lists, formatting all display beautifully)
• —For CSV files, you'll see a formatted table
• —For JSON/YAML, syntax-highlighted code

Right sidebar (metadata):

• —File type and size
• —Current version number
• —Created/modified dates
• —Author information
• —Extracted entities (characters, items, etc.)

Action buttons:

• —Edit - Modify the document
• —History - View all versions
• —Branch - Create an experimental copy
• —Compare - Diff against another version
• —More - Delete, download, move, etc.

Understanding Versions#

See that "v1" badge? That's your version number. Every document starts at v1. Here's the key insight:

In Notion/Google Docs: You edit a document. The old content is gone (mostly). You can sometimes access "version history" but it's vague—"edited 2 hours ago."

In Gameframe: You edit a document. A NEW version is created. v1 still exists, unchanged. v2 contains your edits. Both are accessible forever.

This is the core concept. Every save creates a checkpoint you can return to.

§Part 5: Making Your First Edit#

Editing a Document#

1. 1.Open your document
2. 2.Click the "Edit" button
3. 3.The content becomes editable (markdown editor for .md files)
4. 4.Make a change—try changing "Health: 100" to "Health: 150"
5. 5.Click "Save"

The Change Description Prompt#

When you save, Gameframe asks: "What changed?"

This is important. Write something meaningful:

• —❌ Bad: "updated"
• —❌ Bad: "changes"
• —✅ Good: "Buffed player health 100→150 based on playtest feedback"
• —✅ Good: "Added mage class starting equipment"

Why does this matter? Three months from now, when you're trying to understand why health is 150, you'll see that description. Your future self will thank you.

What Just Happened?#

After saving:

• —Your document now shows v2
• —v1 still exists in history
• —The change description is recorded
• —Timestamp and author are logged
• —AI re-scans for any new entities

You've created your first version-controlled change. But the magic happens in the next step.

§Part 6: Viewing Version History#

Opening History#

Click the "History" button on your document. You'll see a timeline:

v2 - "Buffed player health 100→150 based on playtest feedback"
    by You, 2 minutes ago

v1 - "Initial upload"
    by You, 10 minutes ago

Each entry shows:

• —Version number
• —Change description
• —Author
• —Timestamp

Comparing Versions: The "Aha!" Moment#

This is where Gameframe shines. Click "Compare" and select v1 and v2.

You'll see a diff view:

• —Red lines - Content that was removed
• —Green lines - Content that was added
• —Gray lines - Unchanged context

For your health change, you'd see:

- Health: 100
+ Health: 150

This is what Notion can't do. You see the exact change, not just "edited by Sarah."

Why This Matters: A Real Scenario#

Imagine this: It's 2 AM before a playtest. Someone asks "when did we change warrior health? Was it before or after we nerfed shields?"

In Google Docs: Frantic searching. "Who remembers?" "Check Slack?" "I think it was last Tuesday?"

In Gameframe: Open history. See the exact change, when it happened, who made it, and their reasoning. 30 seconds.

§Part 7: Reverting to a Previous Version#

When to Revert#

Sometimes you need to undo. Common scenarios:

• —Playtest reveals a balance change broke the game
• —Designer realizes the old ability system was better
• —Someone accidentally deleted a section
• —Client/publisher wants to go back to an earlier version

How to Revert#

1. 1.Open document history
2. 2.Find the version you want (e.g., v1)
3. 3.Click "Revert to this version"
4. 4.Confirm

Important: Reverting creates a NEW version (v3) with the old content. Nothing is deleted. Your history becomes:

v3 - "Reverted to v1"
v2 - "Buffed player health..."
v1 - "Initial upload"

This means you can always go back to v2 if needed. Reverting is non-destructive.

§Part 8: Understanding the Gameframe Difference#

Comparison: Gameframe vs. Traditional Tools#

The Mental Model Shift#

Stop thinking of documents as files you edit. Start thinking of them as histories you add to.

Every document is a timeline of decisions. You can travel backward (view old versions), branch off (experiment), and merge back (adopt changes). Just like developers do with code.

§Part 9: What's Next?#

You've completed the basics. Here's your learning path:

Immediate Next Steps#

1. 1.Upload 2-3 real documents from your current project
2. 2.Make meaningful edits and practice writing good change descriptions
3. 3.Compare versions to get comfortable with the diff viewer

Recommended Reading#

• —Version Control 101 - Deep dive into diffs, comparisons, and history
• —Branching Like a Pro - Experiment without breaking things
• —Contractor Access Setup - Add teammates with proper permissions

Features to Explore#

• —Branches - Create experimental copies of documents
• —AI Entities - See extracted characters, items, abilities
• —Quest Log - Built-in task tracking
• —Team Management - Invite collaborators with role-based access

§Quick Reference Card#

§Common Questions#

Q: Can I import from Notion/Google Docs?

A: Export as markdown from Notion, or download as .txt from Google Docs, then upload to Gameframe.

Q: What if I upload the wrong file?

A: Delete it and re-upload. Or just upload the correct version—it becomes v2.

Q: How much does this cost?

A: Free during beta. Indie-friendly pricing coming later.

Q: Can I use this for non-game projects?

A: Absolutely. Any project with evolving documents benefits from version control.

§You're Ready#

Your first vault is set up. Your first document is versioned. You've seen the diff viewer in action and understand why this changes everything.

Welcome to version control for game design. Your future self—the one who doesn't have to ask "which version is current?"—thanks you.

Next up: Read Version Control 101 to master diffs, comparisons, and the full power of document history.

Ready to start? Sign up for free and create your first vault today.