MetaLearn is a platform for tools that help systems understand themselves.
We work at the boundaries between:
- Specification and Implementation (DOL)
- High-level and Low-level (LLVM)
- Human Intent and Machine Execution (Skills)
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ METALEARN.ORG │
│ │
│ "Tools for systems that know what they should be" │
│ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ │ │ │ │ │ │
│ │ dol.metalearn │ │ llvm.metalearn │ │skills.metalearn │ │
│ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │
│ │ Design │ │ Compilation │ │ Composable │ │
│ │ Ontology │ │ & Translation │ │ Capabilities │ │
│ │ Language │ │ Tools │ │ │ │
│ │ │ │ │ │ │ │
│ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │ │
│ └────────────────────┼────────────────────┘ │
│ │ │
│ ┌───────────▼───────────┐ │
│ │ │ │
│ │ metalearn.org │ │
│ │ (Learning Hub) │ │
│ │ │ │
│ └───────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Site: https://dol.metalearn.org
Purpose: A specification language for systems that know what they should be.
Philosophy:
"Understanding outlives implementation."
DOL inverts traditional development:
- Traditional: Code → Tests → Documentation
- DOL: Ontology → Tests → Code
DOL answers: "What IS this system, fundamentally?"
Before DOL: With DOL:
┌─────────────────┐ ┌─────────────────┐
│ Code (Rust) │ │ Ontology (DOL) │ ← Stable meaning
│ "How it works" │ │ "What it IS" │
│ │ ├─────────────────┤
│ Docs (if any) │ │ Code (Rust) │ ← Implementation
│ "What we think │ │ "How it works" │
│ it does" │ ├─────────────────┤
│ │ │ Tests │ ← Generated from spec
│ Tests │ │ "Verified" │
│ "What we test" │ └─────────────────┘
└─────────────────┘
Core Concepts:
- Genes: Properties that define what something IS
- Traits: Behaviors that define what something DOES
- Constraints: Rules that must always hold
- Systems: Compositions of genes, traits, constraints
Tools:
dol-parse: Validate DOL syntaxdol-check: Verify constraintsdol-test: Generate tests from specs
Standard Library:
physics.dol: Thermodynamics, causality, conservationprimitives.dol: Continuants, occurrents, relationstransformations.dol: State transitions, compositioninformation.dol: Encoding, channels, fidelity
Site: https://llvm.metalearn.org
Purpose: Bridge high-level languages to low-level execution through LLVM IR.
Philosophy:
"Meet code where it is, take it where it needs to go."
LLVM Translation answers: "How do we get from HERE to THERE?"
┌─────────────────┐
│ Source Code │
│ (C, Rust, Go) │
└────────┬────────┘
│
┌────────▼────────┐
│ LLVM IR │ ← Universal representation
│ (Intermediate) │
└────────┬────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
┌───────▼───────┐ ┌────────▼────────┐ ┌───────▼───────┐
│ x86_64 │ │ ARM64 │ │ WASM │
│ (Desktop) │ │ (Mobile) │ │ (Browser) │
└───────────────┘ └─────────────────┘ └───────────────┘
Core Capabilities:
- Translation: Between source languages via IR
- Analysis: Understand code structure and semantics
- Optimization: Transform for performance
- Targeting: Emit for any supported architecture
Tools (from llvm-translation-mcp):
- MCP server for LLVM operations
- Claude integration for AI-assisted translation
- Analysis pipelines for code understanding
Site: https://skills.metalearn.org
Purpose: Composable, reusable capability modules for AI agents and systems.
Philosophy:
"Capabilities should be modular, discoverable, and composable."
Skills answer: "What CAN this system do?"
┌─────────────────────────────────────────────────────────────────────────┐
│ SKILL COMPOSITION │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Skill │ + │ Skill │ + │ Skill │ = Complex │
│ │ A │ │ B │ │ C │ Capability │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ Example: │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ CrossPlatform│ + │ MathEngine │ + │ P2PNetwork │ = Distributed │
│ │ Bridge │ │ Integration │ │ Node │ Compute Node │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Existing Skills (from MyceliaNetwork):
- CrossPlatformBridge: Abstract platform differences
- MathEngineIntegration: Numerical computation
- MyceliaNetworkNodeDeployer: P2P node deployment
Skill Structure:
Skills/
├── CLAUDE.md # How Claude uses these skills
├── SkillName/
│ ├── SKILL.md # Skill specification (what it does)
│ ├── src/ # Implementation
│ ├── tests/ # Validation
│ └── examples/ # Usage examples
Integration with DOL: Skills can be specified in DOL, then implemented:
system skill.cross_platform_bridge @ 0.1.0 {
provides platform_abstraction
provides file_system_access
provides network_access
works_on windows
works_on macos
works_on linux
}
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ THE METALEARN STACK │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ INTENT LAYER │ │
│ │ │ │
│ │ "I want a distributed system that processes images" │ │
│ │ │ │
│ └────────────────────────────┬─────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ ONTOLOGY LAYER (DOL) │ │
│ │ │ │
│ │ system image_processor @ 0.1.0 { │ │
│ │ requires skill.distributed_compute │ │
│ │ requires skill.image_processing │ │
│ │ provides transformation.image_to_embedding │ │
│ │ } │ │
│ │ │ │
│ └────────────────────────────┬─────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ SKILLS LAYER │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Distributed │ │ Image │ │ P2P │ │ │
│ │ │ Compute │ │ Processing │ │ Network │ │ │
│ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │
│ │ │ │ │ │ │
│ └──────────┼────────────────┼────────────────┼─────────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ COMPILATION LAYER (LLVM) │ │
│ │ │ │
│ │ Rust → LLVM IR → {x86, ARM, WASM} │ │
│ │ │ │
│ └────────────────────────────┬─────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ EXECUTION LAYER │ │
│ │ │ │
│ │ Running on: Desktop, Server, Edge, Browser │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
metalearn.org/
├── / # Landing page - what is MetaLearn?
├── /tools # Overview of all tools
├── /philosophy # Why we build this way
├── /tutorials # Cross-tool tutorials
└── /community # Discord, GitHub, discussions
dol.metalearn.org/
├── / # What is DOL?
├── /learn # Interactive tutorial
│ ├── /genes # Defining properties
│ ├── /traits # Defining behaviors
│ ├── /constraints # Defining rules
│ └── /systems # Composing all together
├── /reference # Language specification
│ ├── /syntax # Grammar and syntax
│ ├── /stdlib # Standard library docs
│ └── /cli # Tool documentation
├── /examples # Real-world examples
│ ├── /univrs # Univrs ontology examples
│ └── /community # Community contributions
├── /playground # Try DOL in browser
└── /install # Get the tools
llvm.metalearn.org/
├── / # What is LLVM translation?
├── /learn # Tutorials
│ ├── /ir # Understanding LLVM IR
│ ├── /translation # Language-to-language
│ └── /optimization # Performance tuning
├── /tools # Tool documentation
│ ├── /mcp-server # MCP integration
│ └── /claude-flow # AI-assisted translation
├── /examples # Translation examples
└── /install # Setup guide
skills.metalearn.org/
├── / # What are Skills?
├── /catalog # Browse available skills
│ ├── /compute # Computation skills
│ ├── /network # Networking skills
│ ├── /platform # Platform abstraction
│ └── /ai # AI/ML skills
├── /create # How to create a skill
│ ├── /structure # Directory structure
│ ├── /specification # Writing SKILL.md
│ ├── /testing # Testing skills
│ └── /publishing # Sharing skills
├── /compose # Combining skills
└── /install # Using skills
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ METALEARN LEARNING JOURNEY │
│ │
│ BEGINNER │
│ ├── "What problem does MetaLearn solve?" │
│ ├── "How do specs relate to code?" │
│ └── "Try the DOL playground" │
│ │
│ INTERMEDIATE │
│ ├── "Write your first DOL spec" │
│ ├── "Implement a spec in Rust" │
│ ├── "Use a Skill in your project" │
│ └── "Translate code with LLVM tools" │
│ │
│ ADVANCED │
│ ├── "Design an ontology for a new domain" │
│ ├── "Create and publish a Skill" │
│ ├── "Extend the DOL standard library" │
│ └── "Contribute to MetaLearn tools" │
│ │
│ EXPERT │
│ ├── "Build a DOL-first development workflow" │
│ ├── "Integrate LLVM translation into CI/CD" │
│ └── "Design cross-cutting ontologies" │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Modern software development suffers from:
- Semantic Drift: Code diverges from its original intent
- Lost Knowledge: Why decisions were made is forgotten
- Brittle Integration: Systems don't compose well
- Platform Lock-in: Code tied to specific environments
- AI Opacity: AI can generate code but not understanding
MetaLearn provides tools for:
- Semantic Stability: DOL specs preserve meaning
- Knowledge Capture: Ontology IS the documentation
- Clean Composition: Skills are designed to compose
- Platform Freedom: LLVM enables true portability
- AI Alignment: Specs guide AI generation
We bet that:
Systems that understand themselves are more valuable than systems that merely function.
A system with a DOL spec:
- Can explain what it is
- Can verify it behaves correctly
- Can evolve without losing identity
- Can be understood by humans AND AI
Univrs is the proving ground for MetaLearn tools.
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ UNIVRS ECOSYSTEM (Uses MetaLearn) │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ RustOrchestration │ │
│ │ │ │
│ │ Ontology: scheduling.dol, reconciliation.dol, identity.dol │ │
│ │ Skills: ContainerRuntime, Scheduling, P2PNetwork │ │
│ │ LLVM: Rust → native binaries │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ mycelial-dashboard │ │
│ │ │ │
│ │ Ontology: network.dol, economics.dol, reputation.dol │ │
│ │ Skills: P2PNetwork, WebSocket, ReactDashboard │ │
│ │ LLVM: Rust → native + WASM (browser nodes!) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ Univrs proves MetaLearn works. │
│ MetaLearn is bigger than Univrs. │
│ │
└─────────────────────────────────────────────────────────────────────────┘
- ✅ Complete DOL parser and tools (metadol)
- ✅ Validate on Univrs ontology
- 🔄 Create univrs-identity crate
- 🔄 Create univrs-state crate
- 📋 Reorganize repos (DOL specs to their projects)
- Create dol.metalearn.org landing page
- Write "Getting Started with DOL" tutorial
- Document existing Skills
- Create Skills specification format
- DOL playground (in-browser)
- LLVM translation tutorials
- Skills catalog
- Community contributions workflow
- DOL language server (IDE integration)
- Skill marketplace
- Cross-project ontology sharing
- AI-native spec generation
MetaLearn builds tools that help systems understand themselves.
Through DOL, we give systems a language to describe what they are. Through LLVM tools, we enable systems to run anywhere. Through Skills, we make capabilities composable.
We believe the future of software is:
- Specification-first: Know what you're building before you build
- Ontology-grounded: Meaning is explicit, not implicit
- Composable: Small pieces that combine cleanly
- AI-native: Specs that guide both humans and machines
MetaLearn is where understanding meets execution.
"Systems that know what they should be can become what they need to be."