The current internet was never designed to keep your data safe. But the next one will be.

The Blind Computer is the technical foundation for that shift. It’s how we make privacy work. Not just in theory or for limited use cases, but at scale, in production, across real applications and ecosystems.

This technical roadmap dives into the software systems making that possible.

It focuses on the architecture behind the Blind Computer: the components already powering live applications, and the work ahead to bring deeper programmability, stronger privacy guarantees, and more seamless developer experiences.

It’s not a feature list, it’s a blueprint for how we’re making privacy programmable, and usable in the real world.

The Mission

The Blind Computer plays a critical role in a focused mission, ensuring motivated ecosystem developers have the right tools to:

• Help users and organizations protect and control access to their data
• Verify the provenance and accuracy of user data
• Benefit data owners for the value their data provides

Development Principles

Nillion’s approach to building the Blind Computer draws on familiar principles.

The architecture is modular by design, giving developers the flexibility to use each component on its own or integrate multiple components together depending on the use case. It’s built for interoperability, making it easy to connect with existing tools and deploy across different stacks.

The system leans on what already works, utilizing proven tools and open-source components instead of reinventing everything from scratch. Each piece is designed for compatibility with standards like OpenAPI, so developers don’t need to learn entirely new paradigms just to interact with the system. Transparency is built in. The stack is open source, inspectable, auditable, and designed for verification at every layer.

This approach isn’t merely shaped by principles, but by experience. The team members behind the Blind Computer have spent more than a decade working on real-world privacy infrastructure, conducting both NSF-supported and industry-supported research and transition-to-production work on PETs for web applications, data analysis and private matching workflows, and large-scale MPC metrics.

The roadmap is designed to remain flexible, able to adapt to developer needs and shifts in the ecosystem. Each software component can be used individually or combined with others to serve different parts of the mission, both now and over time.

Development Roadmap Overview

A number of Blind Computer core components are already available and in use today. These support secure data storage, LLM workflows, and programmable permissions management. Together, they form the infrastructure layer powering live applications like nilGPT, LouisAI, and Tickr, as well as data-driven services from MonadicDNA, Stadium Science, and others.

These aren’t future-facing prototypes. They’re privacy-preserving systems running in production, with real users.

Developers can learn to work with each component individually or combine them into larger workflows, using the docs as a starting point.

The roadmap itself is structured across three phases.

Phase 0 – Q2 2025

Developers can elect to store encrypted data on decentralized clusters composed of any set of participating nodes, including those operated by leading global enterprises. In that case, data is secret shared and/or encrypted, never exposing it in plaintext to any individual node.

They can also query LLMs via nilAI privately without leaking prompts, completions, or access metadata. Even the infrastructure doesn’t see what’s being processed.

Phase 1 – Q3 2025

The next phase focuses on unlocking interoperability between existing components and introducing auditability across the system.

Developers will be able to incorporate encrypted data, already stored in decentralized clusters directly into LLM queries. This marks the beginning of seamless composition across the stack, where private storage and private inference work hand in hand.

Alongside this, auditability features will be introduced to make system behavior transparent. Developers will gain tools to verify how components operate and how data is handled, without compromising the privacy of the data itself.

Phase 2 – Q4 2025

This phase focuses on enhancements that make it easier for developers to integrate Blind Computer components into real applications, workflows, and services.

Improvements to SDKs, deployment flows, and interface layers will reduce friction and accelerate development. Whether working with a single component or composing multiple parts of the stack, the goal is to streamline the experience so that building with privacy feels as natural as building without it.

​​The Blind Stack in Practice

The Blind Computer is already powering systems in production. Here’s how its components work, and how developers are using them today.

Private Data Storage and Basic Analysis with nilDB

nilDB is a decentralized NoSQL database designed for developers building privacy-preserving applications that need to integrate seamlessly with existing development environments.

For standard app development, the secretvaults SDKs (available in both TypeScript and Python) offer a simple way to work with decentralized clusters, enabling secret sharing of private data using multi-party computation (MPC).

For more advanced use cases, developers can access each nilDB node directly via its OpenAPI-compatible REST API. Nodes function independently, and clusters can be composed from any subset, without requiring coordination or mutual awareness between nodes.

The blindfold library adds support for multiple encryption methods, including traditional at-rest encryption, threshold MPC encryption, and homomorphic encryption using the Paillier cryptosystem. Developers can choose the level of protection based on their application’s needs.

nilDB also supports hybrid storage, allowing plaintext and ciphertext fields to coexist within the same document. This enables flexible schema design and performance optimization, even in distributed, multi-node deployments.

Advanced Computation and AI Workflows with nilAI and nilCC

nilAI allows users to query AI models and receive responses without exposing prompts or completions to the infrastructure. Queries are processed privately, with full confidentiality preserved from beginning to end.

Each nilAI node runs on nilCC, a secure compute framework built on trusted execution environments (TEEs). These environments provide hardware-enforced privacy during execution, supported by remote attestation, trust bootstrapping, and open-source measurement techniques.

This setup powers privacy-preserving AI services already in use today. nilGPT uses nilAI to serve blind LLM queries, while LouisAI runs meeting summarization workflows that never reveal raw transcripts or summaries to node operators.

Decentralized Data Access Control and Delegation with NUCs and nilAuth

NUCs and nilAuth provide the access control layer of the Blind Computer, allowing data owners to define, delegate, and revoke permissions over their data.

Built on an extension of UCAN, this framework supports user-originated, cryptographically signed policies for read, write, and compute access. Permissions are enforced at the system level, without relying on centralized coordination.

Tickr uses this model to let traders control access to encrypted performance metrics, enabling trust without exposing sensitive information.

To get started with NUCs, see the documentation page on network API access.

Why It Matters

The Blind Computer isn’t just a stack, it’s a foundation to build with.

As the components continue to evolve through the phases ahead, developers will be able to do more than just store data or query models privately. They’ll be able to compose full workflows: blind storage, private compute, permissioned access, and real-time compensation, all programmable, all enforceable at the system level.

This opens up a different kind of development path. One where trust is built into the infrastructure. One where privacy isn’t something you bolt on, it’s something you inherit from the system itself.

The Blind Computer isn’t a finished product. It’s an environment that gets more capable, more interoperable, and more developer-friendly with each release.

And what gets built on top of it, that part’s just getting started.

If you’re a developer looking to build blind apps with privacy at the core, follow our quickstart guide to get started today.