The world's first real-life strategy game where your legs are your army.
Project Kappa is a GPS-native multiplayer strategy game where real-world movement shapes a persistent shared map.
Players move through the real world, explore and interact with territory, and influence a shared game world through physical activity.
The product combines running, maps, territory control, and multiplayer strategy into a single gameplay experience.
Project Kappa is currently in alpha testing.
Most fitness applications treat a run as a private activity measured through:
- Distance
- Pace
- Calories
- Routes
- Personal records
Project Kappa adds a persistent multiplayer layer to physical movement.
A run can become an interaction with a shared world.
Players can:
- Explore the map through movement.
- Interact with territory.
- Influence the state of the world.
- Compete with other players.
- Review their activity and gameplay history.
- Watch the shared map evolve over time.
The goal is to make the physical environment part of the game rather than simply using GPS as a fitness-tracking feature.
Project Kappa turns physical movement into a multiplayer game input.
The player does not simply record a route.
Their movement becomes part of a persistent world that can be observed and influenced over time.
Your route becomes part of the game.
The map is the primary gameplay surface.
flowchart LR
A[Start Run] --> B[Move Through Real World]
B --> C[Interact With Territory]
C --> D[Sync Progress]
D --> E[World Updates]
E --> F[Review Results]
F --> B
At a high level:
Run
↓
Explore
↓
Interact
↓
Influence
↓
Sync
↓
Shared World
↓
Repeat
The specific rules governing territory, scoring, competition, progression, and other gameplay systems are intentionally not documented in the public repository.
Project Kappa is built around a simple idea:
What if your physical movement could change a game world shared with everyone around you?
Traditional running applications primarily measure activity.
Traditional strategy games primarily simulate movement.
Project Kappa connects the two.
The real world becomes the game board, while physical movement becomes one of the primary ways players interact with it.
Project Kappa is currently in alpha testing.
The repository contains working development versions of:
- GPS-based movement processing
- Territory gameplay systems
- Run session management
- Backend APIs
- World-state management
- Flutter mobile client
- Synchronization
- Map-based gameplay
- Automated testing
- Simulation tooling
- Web-based development surfaces
The current implementation is focused on validating the underlying game system and real-world gameplay experience.
Project Kappa is organized around four major layers:
flowchart LR
subgraph Input["Real-World Input"]
GPS["GPS Location"]
USER["Player Actions"]
AUTH["Authentication"]
end
subgraph Mobile["Mobile"]
APP["Flutter App"]
LOCAL["Local State"]
SYNC["Synchronization"]
APP --> LOCAL
APP --> SYNC
end
subgraph Backend["Backend"]
API["Backend API"]
AUTHS["Authentication"]
RUNS["Run Sessions"]
WORLDAPI["World API"]
SYNCS["Sync Service"]
API --> AUTHS
API --> RUNS
API --> WORLDAPI
API --> SYNCS
end
subgraph Game["Game Systems"]
ENGINE["Gameplay Engine"]
SPATIAL["Spatial Processing"]
TERRITORY["Territory Systems"]
WORLD["World State"]
ENGINE --> SPATIAL
ENGINE --> TERRITORY
ENGINE --> WORLD
end
subgraph Storage["Persistence"]
DB["SQLite"]
DATA["Game Data"]
DB --> DATA
end
subgraph Output["Game Experience"]
MAP["Territory Map"]
STATS["Statistics"]
HISTORY["Run History"]
EVENTS["Game Events"]
end
GPS --> APP
USER --> APP
AUTH --> APP
APP --> API
SYNC --> API
API --> ENGINE
ENGINE --> DB
WORLD --> MAP
DB --> STATS
DB --> HISTORY
DB --> EVENTS
Responsible for:
- GPS collection
- Map interaction
- Run sessions
- Local state
- Synchronization
- Gameplay presentation
Responsible for:
- Authentication
- API services
- Run management
- Synchronization
- World-state access
Responsible for:
- Spatial gameplay
- Territory interactions
- Gameplay processing
- World-state transitions
The internal algorithms and proprietary gameplay rules are intentionally kept private.
Responsible for:
- Player data
- Run data
- Territory data
- World-state information
- Related gameplay records
Project Kappa represents the game world using spatial data.
A player's movement produces a sequence of location information that can be processed by the game systems.
At a conceptual level:
Location Data
↓
Movement Processing
↓
Spatial Processing
↓
Game Systems
↓
World State
↓
Map
The exact territory model, capture rules, scoring logic, ownership rules, and balancing parameters are proprietary and are not documented publicly.
The territory engine is designed to remain independent from the mobile client so that game systems can be tested and simulated separately.
GPS is a fundamental part of Project Kappa because physical movement directly affects gameplay.
The system is designed to handle real-world location conditions including:
- Location accuracy
- Sampling intervals
- Movement continuity
- Duplicate data
- Connectivity interruptions
- Unexpected location changes
- Spatial consistency
GPS data is treated as gameplay input rather than simply as a fitness metric.
The implementation includes processing between raw location data and gameplay state.
Specific validation algorithms and anti-abuse mechanisms are intentionally excluded from public documentation.
The Flutter mobile MVP lives in mobile/.
The current client is intentionally map-first and communicates with the /api/v1 backend.
Current development capabilities include:
- Development authentication
- Run creation
- Active run recovery
- GPS point collection
- Point synchronization
- Run completion
- World-state retrieval
- Run history
The mobile client is an active development build and does not yet represent the final consumer application.
Real-world movement does not always happen with a reliable network connection.
The mobile client therefore includes local state and synchronization capabilities designed to support movement during temporary connectivity interruptions.
Conceptually:
GPS
↓
Mobile Client
↓
Local State
↓
Connection Available
↓
Synchronization
↓
Backend
↓
World State
The public implementation describes the synchronization architecture without exposing internal conflict-resolution or gameplay-authority rules.
project-kappa/
│
├── backend/
│ ├── API
│ ├── game services
│ ├── simulation services
│ └── territory systems
│
├── mobile/
│ ├── Flutter application
│ ├── map experience
│ ├── run tracking
│ └── synchronization
│
├── frontend/
│ └── web-facing product surfaces
│
├── docs/
│ └── public project documentation
│
├── data/
│ └── local datasets and development artifacts
│
└── scripts/
└── automation and utility scripts
Project Kappa currently demonstrates:
- GPS-based gameplay
- Territory-based multiplayer systems
- Spatial game systems
- Flutter mobile development
- Node.js backend development
- Backend API design
- Run session management
- World-state synchronization
- Offline-aware mobile architecture
- Map-first gameplay
- Automated testing
- Simulation-driven development
- Real-world location processing
The project is structured so the mobile client, backend, and game systems can evolve independently.
The current interface is being used for gameplay and field testing.
The current UI is an alpha development interface and is expected to evolve significantly during development.
Install the required Node.js and Flutter dependencies before running the respective components.
npm run devThe local development server is available at:
http://127.0.0.1:8000
npm testThe Flutter application is located at:
mobile/
See mobile/README.md for mobile-specific development instructions.
| Layer | Technology |
|---|---|
| Mobile | Flutter |
| Backend | Node.js |
| Game Systems | Custom territory and simulation systems |
| Spatial Data | Spatial systems |
| Persistence | SQLite |
| Infrastructure | Oracle Cloud |
| Testing | Automated unit/integration testing |
The public repository focuses on how the current system is structured and developed.
Proprietary gameplay mechanics and internal product strategy are intentionally excluded.
The following categories are not documented publicly:
- Exact territory algorithms
- Capture calculations
- Scoring formulas
- Ownership rules
- Balancing parameters
- Internal progression systems
- Anti-cheat implementation
- Location-validation algorithms
- Internal simulation parameters
- Unreleased gameplay systems
- Competitive strategy
- Future product plans
This allows the project to remain technically transparent without publishing the systems that define the game's deeper design.
Public documentation focuses on:
- Architecture
- Development setup
- Mobile development
- API usage
- Testing
- Deployment
- Current alpha functionality
Implementation details that expose proprietary gameplay logic should remain in private/internal documentation.
Project Kappa is being developed incrementally.
Current development areas include:
- Mobile gameplay
- GPS and movement processing
- Territory systems
- Multiplayer world state
- Synchronization
- Field testing
- Gameplay iteration
- Performance
- Reliability
Specific gameplay mechanics and future systems may change as development continues.
The map is the primary gameplay surface.
Physical movement should have meaningful consequences inside the game world.
The world is intended to be shared rather than isolated to an individual player.
The game must work under real-world GPS and connectivity conditions.
Gameplay state should be based on trustworthy inputs and robust systems.
The alpha phase is focused on validating the gameplay experience through simulation and real-world field testing.
The project is currently focused on:
flowchart LR
A[Core Game Systems]
B[GPS Reliability]
C[Mobile Gameplay]
D[World Synchronization]
E[Field Testing]
A --> C
B --> A
C --> D
D --> E
E --> A
The objective of the alpha phase is to validate the fundamental interaction between:
physical movement → gameplay → shared world
before expanding the product further.
Status: Alpha Testing
Mobile: Flutter MVP
Backend: Node.js
Game Engine: Custom territory and simulation systems
Infrastructure: Oracle Cloud
Persistence: SQLite
Gameplay: GPS-native multiplayer territory strategy
This project is licensed under the MIT License.
See LICENSE for details.