Build ON the OS. DOSFI handles the rest.
Everything you need to run a node or ship a mesh-native app against the DOSFI ABI — powered by the MeshInfer.AI runtime.
Blockchain Ecosystems That Benefit from DOSFI
DOSFI's distributed-inference architecture, Vital compute-energy model, DIU pricing engine, and MNE deterministic settlement enhance every blockchain family that requires intelligence at scale. Explore how each ecosystem category gains unique advantages.
Ecosystem Compatibility Summary
| Chain Family | Chains | Key Benefits | Architectural Fit |
|---|---|---|---|
| High-Speed Chains | Avalanche, Solana, NEAR | Sub-millisecond inference, shard-parallel execution, subnet-aware routing | Mesh scheduler matches TPS throughput without centralization |
| AI-Focused Chains | DOS Chain, Injective, Cosmos | Agent execution, cross-chain inference via IBC, DIU pricing, MNE settlement | Deterministic settlement and composable routing align with AI-native chain design |
| Enterprise Chains | Ethereum/EVM, Hedera, Algorand | Sovereign on-prem inference, Privacy Tier T0, Vital-priced compliance | Identity Fabric and audit-trail anchoring satisfy regulated industry requirements |
| Gaming Chains | Avalanche Subnets, Polygon, Immutable X | Edge NPC inference, real-time game logic, frictionless DIU-priced compute | Edge distribution and single-digit-ms latency match real-time game frame budgets |
Chain-Agnostic Infrastructure
DOSFI enhances any ecosystem that needs distributed intelligence.
DOSFI is not a blockchain and does not compete with any chain. It is the AI execution layer that sits above all chains — chain-agnostic by design, sovereign by architecture, and economically predictable by model. Any ecosystem that requires distributed intelligence, sub-second inference latency, predictable compute economics, or sovereign AI execution gains immediate value from integrating DOSFI. The four families above represent the highest-density opportunity, but DOSFI's Privacy Tier system, MNE settlement, and DIU pricing engine are general-purpose primitives ready for any chain family that builds on top of them.
Enterprise / Setup
Deployment Guide
Step-by-step walkthrough for connecting your first mesh node — from prerequisites to a live shard-accepting node.
Deep-dive technical documentation.
WP_01 · PDF · 42 pages
Post-Quantum Encryption in DOSFI
A comprehensive technical overview of DOSFI's post-quantum cryptographic primitives — lattice-based key encapsulation, signature schemes, and how they protect every link and payload across the mesh against quantum adversaries.
WP_02 · PDF · 38 pages
Zero-Trust Orchestration Architecture
Full specification of DOSFI's zero-trust execution model — node attestation, shard isolation, continuous verification, and how the mesh maintains cryptographic integrity across untrusted heterogeneous devices.
import { DOSFI } from "@meshinfer/sdk";
// Connect to the mesh via the published ABI
const mesh = await DOSFI.connect({ token: process.env.DOSFI_TOKEN });
// Submit a workload — DOSFI partitions, schedules, and routes it
const task = await mesh.tasks.submit({
workload: "inference",
model: "meshinfer/runtime",
privacyTier: "tier-2",
payload: input,
});
// Stream verified results as nodes complete shards
for await (const result of task.stream()) {
console.log(result.nodeId, result.verified, result.output);
}Resource Library
Every guide, API reference, tutorial, whitepaper, and lab — searchable in one place.
50 results
Getting Started with DOSFI
Install the node client, authenticate, and join the mesh in minutes. Submit your first task in under 5 minutes.
Enterprise Deployment Guide
Step-by-step walkthrough for connecting your first mesh node — from prerequisites to a live shard-accepting node.
DOSFI Studio — Visual Builder
Build mesh-native apps visually — drag, compose, and deploy without writing boilerplate.
Task API Reference
Submit, partition, and track workloads. DOSFI shards the task and returns verified results as nodes complete their units.
Node API Reference
Inspect node readiness, capacity, thermal headroom, and trust tier. Manage participation programmatically.
Routing API Reference
Express routing constraints and privacy tiers. The closed-source router selects optimal paths within your declared boundaries.
MeshInfer Runtime API
Target the MeshInfer.AI runtime for inference workloads — it executes, optimizes, and verifies every shard across the fabric.
SDK Reference — JavaScript
Full API reference for the official DOSFI JavaScript SDK including connection, task submission, and state management.
SDK Reference — Python
Full API reference for the official DOSFI Python SDK including async task execution and distributed state.
SDK Reference — Rust
Full API reference for the DOSFI Rust SDK with performance-optimized task submission and node interaction.
ABI Boundary Explained
The stable contract you build against. Everything above is open and yours; everything below is sealed and operated by DOSFI.
DOSFI System Architecture
Scheduler, routing engine, readiness scoring, thermal management, and zero-trust execution — all layers explained.
Transport Layer Deep Dive
How DOSFI transports shard payloads across heterogeneous network conditions — latency budgets, retry logic, and fallback routing.
Privacy Tier Model (T0–T5)
Full specification of DOSFI's six-tier privacy model — from fully public mesh routes to sovereign on-prem isolation.
Identity Fabric & @dosfi.ai
Mesh-native identity architecture — node attestation, operator credentials, and the @dosfi.ai cryptographic identity protocol.
Mesh-Native App Model
How DOSFI's app runtime, workflow engine, state machine, and routing policies compose into a full mesh-native application.
Zero-Trust Execution Model
Node attestation, shard isolation, and continuous verification — how DOSFI maintains cryptographic integrity across untrusted devices.
Post-Quantum Encryption Overview
Lattice-based key encapsulation and signature schemes that protect every link and payload across the mesh against quantum adversaries.
Security Audit Report
Comprehensive security audit across identity, routing, inference, and MNE settlement domains — findings and remediations.
IP & Open Source Policy
What DOSFI open-sources and what remains sealed — with full rationale and IP boundary definitions.
Blockchain Ecosystem Integrations
How DOSFI enhances Avalanche, Solana, NEAR, DOS Chain, Injective, Ethereum, Hedera, Polygon, and Immutable X.
Ecosystem Partners Overview
Strategic integrations with Starlink, BitTorrent, and other mesh-adjacent infrastructure partners.
Starlink Partnership
How DOSFI routes compute across Starlink's low-latency LEO satellite network for global edge inference.
BitTorrent Partnership
How DOSFI leverages BitTorrent's distributed content delivery infrastructure for shard distribution at planetary scale.
Bypassing the Cloud
Technical rationale for why mesh-native inference outperforms centralized cloud for latency-sensitive and privacy-sensitive workloads.
Build Your First Mesh-Native App
From project scaffold to a live task submission in under 30 minutes using the DOSFI JavaScript SDK.
Using DOSFI Studio
Visual builder walkthrough — build and deploy a mesh-native app without writing boilerplate code.
Provisioning a Mesh Node (Android)
Install the open-source node client, grant compute consent, and start earning Vital from idle device compute.
Provisioning a Mesh Node (iOS)
Configure your iOS device as a DOSFI compute node — readiness scoring, thermal management, and shard acceptance.
Post-Quantum Encryption in Practice
Apply lattice-based cryptographic primitives to your mesh workloads using the DOSFI SDK's built-in crypto layer.
Configuring Privacy Tiers
How to declare routing constraints and privacy tiers in your app so the DOSFI router selects compliant paths.
Zero-Trust Orchestration Setup
Configure node attestation, shard isolation, and continuous verification for enterprise mesh deployments.
Sovereign On-Prem Inference
Deploy DOSFI with Privacy Tier T0 so all inference stays within your institutional perimeter — never touching the public mesh.
DIU Pricing & Vital Settlement
Understand how Distributed Intelligence Units price compute and how Vital settles inference economics deterministically.
Post-Quantum Encryption in DOSFI
42-page technical overview of DOSFI's lattice-based cryptographic primitives and how they protect the mesh against quantum adversaries.
Zero-Trust Orchestration Architecture
38-page full specification of DOSFI's zero-trust execution model — node attestation, shard isolation, and continuous verification.
Digital Currency vs. Vital (DIU)
Why Vital is a compute-energy unit (DIU), not a financial asset — and how it differs from BTC, ETH, stablecoins, and CBDCs.
Bypassing the Cloud — Technical Brief
Performance and cost analysis of mesh-native inference vs. centralized cloud for LLM, CV, and scientific computing workloads.
Open Source & IP Policy
What DOSFI open-sources (node client, SDK, ABI) and what remains sealed (router, scheduler, MNE) — with full rationale.
Distributed Intelligence Fundamentals
Learn the foundations of mesh computing, edge inference, and device coordination — the bedrock of DOSFI development.
Building on the DOSFI ABI
A hands-on course covering the Task, Node, and Routing APIs end-to-end with real workload submissions.
Post-Quantum Security for Developers
Hands-on cryptographic security course tailored to mesh-native development — lattice keys, shard signing, and attestation.
Mesh-Native App Architecture
Deep-dive course on the DOSFI app runtime, workflow engine, state machine, and how they compose into production apps.
Distributed Intelligence Engineer
Enterprise-grade certification from DOSFI University for advanced mesh engineers — recognized by DOSFI partners.
DOSFI Security Practitioner
Certification covering zero-trust orchestration, post-quantum encryption, and privacy tier compliance in production deployments.
Interactive Labs — All Tracks
Browser-based labs covering fundamentals, mesh-native app model, enterprise security, and ecosystem integrations.
Lab: Node Readiness Scoring
Simulate how DOSFI scores device readiness across compute, battery, thermal, and connectivity dimensions.
Lab: Shard Distribution & Verification
Observe how DOSFI partitions a workload into shards, distributes across nodes, and verifies the assembled result.
Lab: Privacy Tier Routing
Configure routing policies and observe how DOSFI's router selects compliant paths for each privacy tier.
Onboarding Simulation
Walk through the full DOSFI developer onboarding flow — enrollment, course progress, exam, and certificate issuance.
DOC_01
Getting Started
Install the node client, authenticate, and join the mesh in minutes. Then point an SDK at the published ABI and submit your first task.
DOC_02
Installing the Node Client
Download the open-source client for Android or iOS, grant compute consent, and your device begins scoring readiness and accepting shards.
DOC_03
Building Mesh-Native Apps
Mesh-native apps run on the proprietary app runtime against a stable ABI. You write the app; DOSFI schedules and routes; MeshInfer.AI executes.
DOC_04
Task API
Submit, partition, and track workloads. DOSFI shards the task and returns verified results as nodes complete their units.
DOC_05
Node API
Inspect node readiness, capacity, thermal headroom, and trust tier. Manage participation programmatically.
DOC_06
Routing API
Express routing constraints and privacy tiers; the closed-source router selects optimal paths within your declared boundaries.
DOC_07
ABI Boundary
The stable contract you build against. Everything above is open and yours; everything below is sealed and operated by DOSFI.
DOC_08
MeshInfer Runtime Usage
Target the MeshInfer.AI runtime for inference workloads — it executes, optimizes, and verifies every shard across the fabric.
Ready to Build?
Use DOSFI Studio — our visual builder — to create mesh-native apps without writing boilerplate. Drag, compose, and deploy in minutes.
DOSFI Studio — Build Mesh‑Native Apps Visually
A visual builder for workflows, state machines, routing policies, UI schemas, and storage schemas — all running against the stable DOSFI ABI and powered by the MeshInfer.AI runtime.
STUDIO / OVERVIEW
The official builder environment for mesh-native apps
DOSFI Studio is the canonical development environment for building applications that run natively on the DOSFI OS. Rather than constructing mesh orchestration logic in raw API calls, Studio provides a structured visual surface that maps directly to the published ABI — so every workflow, state machine, and routing policy you design compiles to the same schema that the DOSFI scheduler and MeshInfer.AI runtime consume in production.
Visual workflow design
Compose mesh-native workflows as directed graphs against the DOSFI task API.
State machine modeling
Define application state transitions with a visual FSM editor; export directly to ABI-compatible schemas.
Routing policy configuration
Set privacy tiers, geographic constraints, and trust requirements without writing router directives by hand.
UI schema creation
Build declarative UI schemas that the mesh-native app runtime renders on any consenting device.
Storage schema definition
Design distributed storage schemas with partition keys, encryption tiers, and replication hints.
Device-as-renderer previews
Simulate how your UI schema renders across different device form factors in the mesh.
Mesh simulation
Run a local mesh simulation with configurable node counts, load profiles, and privacy tiers.
STUDIO / WEB
Studio Web Version
The browser-based version of DOSFI Studio runs entirely in-browser with no local installation required. It connects directly to the DOSFI ABI over your authenticated session, making it the fastest path to first contact with the mesh-native development model.
- Ideal for onboarding and initial exploration
- Full tutorial library with guided walkthroughs
- Rapid prototyping against live ABI endpoints
- No build tooling or local runtime required
- Shareable workspace links for collaborative review
STUDIO / DESKTOP
Studio Desktop Version
The desktop version (Electron-based, with native builds forthcoming) provides deeper system integration for professional developers who require local inference node access, offline schema editing, and direct connection to a locally provisioned DOSFI node daemon.
- Local DOSFI node integration via IPC
- Offline schema authoring and validation
- Direct connection to local MeshInfer.AI runtime
- Advanced plugin system and custom renderer support
- Git-native project structure for version control
Continue Learning
Building your first mesh-native workflow
Connect nodes, submit a task via the ABI, and stream verified results to a UI schema.
6 tutorials remaining
Learning Progress
0 / 6 completeTUT_01
Building your first mesh-native workflow
TUT_02
Designing a state machine
TUT_03
Creating routing policies
TUT_04
Defining UI schemas
TUT_05
Previewing device rendering
TUT_06
Simulating mesh inference
Templates
Jumpstart with Pre-Built Projects
Browse production-ready mesh-native app templates. Start with a working foundation and customize for your use case.
STUDIO / TUTORIALS
Guided Tutorials
STUDIO / TEMPLATES
Starter Templates
STUDIO / MESH_SIMULATOR
Built-In Mesh Simulator
The Mesh Simulator provides a configurable local environment for observing how the DOSFI scheduler and MeshInfer.AI runtime would behave against your workload under different mesh conditions. Configure node count, load distribution, privacy tier mix, and thermal profiles — then submit a task and observe the full orchestration lifecycle without touching production infrastructure.
Node readiness
Real-time readiness score distribution across the simulated mesh, per thermal and trust tier.
Shard distribution
Live visualization of how the scheduler partitions and assigns workload shards across nodes.
Routing paths
Animated hop-by-hop routing paths from scheduler to executing nodes and back to the requester.
Privacy tier enforcement
Color-coded overlay showing which nodes qualify for each privacy tier at runtime.
Thermal headroom
Per-node thermal utilization gauge updated each simulation tick to reflect real Readiness Engine scoring.
Trust tier behavior
Observe how nodes with different attestation statuses are selected, de-scored, or excluded.
STUDIO / PLUGIN_SYSTEM
Plugin System
DOSFI Studio exposes a structured plugin API that allows developers to extend the builder with custom panels, schema validators, code generators, and renderer previews. Plugins are sandboxed from the Studio core and interact exclusively through the published Studio Extension ABI — a subset of the main DOSFI ABI surface. Plugin manifests are version-pinned to ensure compatibility across Studio releases. Custom plugins can be loaded from a local directory during development and distributed through the DOSFI plugin registry for team or community use.
Extension ABI
Plugins bind to a stable, versioned subset of the DOSFI ABI surface.
Sandbox isolation
Plugin execution is isolated from the Studio core and from other plugins.
Plugin registry
Distribute and install plugins via the DOSFI plugin registry or local path.
Build Your First Mesh-Native App
Follow these four simple steps to create, test, and deploy a mesh-native application using DOSFI Studio — no boilerplate required.
- Enter your app name (e.g., 'My ML Pipeline')
- Select JavaScript or Python as your runtime
- Studio auto-generates your ABI-compliant scaffold
Ready to start building? Open DOSFI Studio and follow the in-app guided tutorial for an interactive walk-through.
Open DOSFI StudioStudio FAQs — Building Mesh-Native Apps Visually
Common questions about the DOSFI Studio builder, exporting schemas, plugins, and the mesh simulator.
Join the Developer Community
Connect with developers building mesh-native apps, share your projects, and learn from the community.
Discord Community
Real-time chat with mesh-native developers, ask questions, and get instant feedback.
GitHub Discussions
Share your mesh-native app builds, propose features, and contribute to open-source initiatives.
Studio Tips & Tricks
Exchange DOSFI Studio workflows, optimization patterns, and advanced techniques.
Community Stats
Active Developers
2,400+
Shared Apps
480+
Tips & Guides
1,200+
Share Your Build
Have a mesh-native app you'd like to showcase? Post it in GitHub Discussions or Discord and get feedback from the community.
Answers to the questions we hear most.
From mesh nodes and latency to task management and security — everything you need to get started.
FAQ / COMMON_QUESTIONS
Frequently Asked Questions
Plain-English definitions for every DOSFI concept.
Click any term to expand a simple explanation alongside the full technical detail.
GLOSSARY / KEY_TERMS