Why Prime AppStore
Source Transparency
Every app includes its Canon inputs and transformation charts, ensuring complete transparency about where information comes from.
Deterministic Behavior
All applications are guaranteed to produce the same output from the same input, every time. No more unpredictable behavior.
One-Click Deployment
Deploy applications locally or across your network with a single command. All apps are self-contained and portable.
Featured App
TruthTracer AI
The first AI assistant with 100% verifiable sources. Every response is traceable to its origin, eliminating hallucinations and ensuring factual accuracy.
TruthTracer AI
Semantic AI Assistant
Categories
See AllTop Apps
See AllTruthTracer AI
Semantic AI Assistant
The first AI assistant with 100% verifiable sources. Every response is traceable to its origin.
DataSovereign
Data Management
Take control of your data with this powerful management tool. Maintain ownership while enabling secure sharing.
TrustChain
Supply Chain Verification
Track products from source to destination with full semantic context and verifiable provenance.
KnowledgeGraph
Educational Tool
Create personalized learning paths with semantic relationships between concepts for deeper understanding.
Prime SDK
Build → Ship → Run Deterministic Apps with Embedded UOR
Prime SDK is a modern developer toolkit for building deterministic, composable, and source-resolved applications using the Universal Object Resolution (UOR) framework. Inspired by Docker's developer experience, Prime SDK gives you the tools to package structured logic into portable UOR containers — then deploy and run them anywhere with mathematical confidence.
You don't just write code — you define logic that is verifiable, traceable, and repeatable.
Why Prime SDK is Different
Prime SDK is built for developers who need more than "it works on my machine." It's for teams shipping applications where correctness, reproducibility, and clarity matter.
Traditional SDKs give you access to APIs and libraries. Prime SDK gives you access to structure — a way to build logic systems that always resolve the same way, with full provenance.
It's powered by three embedded layers of the UOR framework:
UOR Math Package
A deterministic math engine that transforms inputs into outputs through a 12-layer logic stack — encoding structure, resolving meaning, and enforcing coherence.
Protocol Layer
Declarative protocols define how apps interoperate, resolve identity, validate coherence, and version safely. They're logic-native — not just transport wrappers.
Client/Server Runtime
A lightweight virtual machine for running Prime Containers anywhere — local, remote, or distributed — with the same guaranteed result.
Build → Ship → Run
1Build
Author deterministic applications using Prime's math-first logic system:
- Define Canon inputs: raw data, rules, or models
- Compose charts to transform them through the Cortex (logic layer)
- Output structured, verifiable containers (Prime Containers) using the Codex
You can build apps that behave like software and reason like proofs.
2Ship
Push and distribute your apps with complete traceability:
- Publish to the Prime Appstore
- Share across environments or embed in larger systems
- Version and verify containers with full coherence and provenance
Your logic ships with context — not just code.
3Run
Execute your application anywhere, knowing it will always behave the same:
- Use the Prime Runtime or CLI to run containers in dev, test, or production
- Spin up multi-node resolution networks for collaborative execution
- Expose logic via APIs, hooks, or external protocols
Run the exact logic you built — no divergence, no drift.
Use Prime SDK When:
- You're building agents that need deterministic memory or behavior
- You want to ship scientific or financial logic with full auditability
- You need infrastructure logic that can be verified, shared, and remixed
- You're tired of pipelines built from opaque, untraceable tools
- You care about meaning, not just data
What You Get
- Prime CLI (build, run, push, inspect)
- Language SDKs (Python, Rust, TypeScript in progress)
- Lightweight deterministic runtime
- Full access to UOR's embedded math and protocol layers
- Integration with the Prime Appstore for discovery and distribution
Quick Start Example
import { Canon, Codex, Cortex } from '@prime/sdk';
const app = new PrimeApp({
name: 'MyFirstApp',
version: '1.0.0'
});
const canon = new Canon({
source: 'data.json',
type: 'reference'
});
const cortex = new Cortex({
transform: 'semantic-resolution',
rules: ['coherence', 'traceability']
});
await app.build({
canon,
cortex,
output: './my-prime-container'
});Start Building with Clarity
You've shipped apps before. But not like this. Prime SDK gives you the structure to build systems that are clear, deterministic, and composable from day one.
Build smarter. Ship with confidence. Run with integrity.
What Developers Are Saying
Dr. Sarah Chen
Research Scientist
"Prime SDK has transformed our research process. Being able to trace every piece of information back to its source has eliminated errors and accelerated our work."
Michael Rodriguez
CTO, FinTech Innovations
"The deterministic nature of the Prime SDK is a game-changer for our financial systems. We can finally guarantee consistent behavior and full auditability."
Prof. James Wilson
Educational Technology
"Building with Prime SDK has revolutionized how we teach complex subjects. The semantic relationships between concepts help students build deeper understanding."
Ready to Explore?
Discover a new generation of applications built with mathematical precision, semantic clarity, and full traceability. The Prime AppStore is your gateway to the future of software.