The contribution by Shielded Technologies marks a big milestone in open sourcing the development of tools to advance the vision of a privacy-preserving internet.
Introduction
Zero-knowledge proof technology is fundamentally transforming trust and data sharing paradigms across the internet. By applying ZK to decentralized, open, and permissionless blockchain protocols, Web3 is leading the charge against an increasingly leaky (and oftentimes abusive) system for sharing data globally. However, working with ZK proofs can be complex, usually requiring very specialized knowledge and specific tools – slowing down adoption and implementation.
Conceived to abstract the complexity of ZK technology in a way that is both familiar and accessible to developers, the Compact language is the driving force behind the dual-state, public-private ledger architecture that powers the Midnight network. Compact is a strongly statically typed, bounded smart contract language, designed to be used in combination with TypeScript for writing smart contracts on Midnight.
Now both the Compact language and its associated tooling, initially developed and maintained by the team at Shielded Technologies, are being handed over to the LF Decentralized Trust (LFDT). The move embodies the same ethos of openness and collaboration that gave rise to blockchain itself. Along with the new home comes a new name: under the stewardship of LFDT, Compact becomes Minokawa, in homage to the dragon-like bird from Philippine mythology that eclipses the sun.
This contribution taps the power of community and open source and governance to accelerate the development and adoption of privacy-preserving solutions, advancing the vision of a more trustworthy internet.
About Minokawa
Minokawa joins the LFDT project ecosystem as an established codebase and with an existing user base. It was designed under the Compact brand with a clear set of goals: to make zero-knowledge smart contract development accessible, secure, and practical for real-world applications. Compact’s features and capabilities are now at the core of Minokawa. They include:
Privacy by default
Privacy is not an add-on. In Minokawa it’s the baseline. Any data originating from private sources (witness data) is treated as confidential by default. Developers must explicitly use the disclose keyword to reveal private values, which prevents accidental data exposure and reinforces a mindset of minimum disclosure. This selective disclosure model allows DApps to share only what is necessary for verification or compliance, while keeping all other data private.
Strong static typing
Minokawa is a strongly and statically typed language. Every expression has a well-defined type at compile time, and the compiler validates type correctness throughout the contract. This improves contract safety, reduces runtime errors, and makes logic easier to reason about and audit.
Zero-Knowledge proof integration
Zero-knowledge is built into the language itself. The Minokawa compiler generates the necessary circuits and cryptographic artifacts required for proof generation and verification. Developers can write standard contract logic, and the compiler ensures that all sensitive operations are compiled with privacy-preserving proofs without requiring deep knowledge of constraint systems or cryptographic internals.
Separation of public and private state
Minokawa supports a dual-state model. Contracts can define both public on-chain state and private off-chain state tied to specific users. This separation enables fine-grained control over visibility and allows applications to process user-specific data privately while maintaining verifiable outcomes on-chain.
Developer accessibility
Minokawa is designed to be approachable and familiar. Its syntax resembles TypeScript where possible, and the compiler outputs fully typed JavaScript/TypeScript APIs with source maps and runtime checks. This makes it easy to integrate Minokawa contracts into modern web development environments and ensures a smooth developer experience from backend logic to frontend interfaces.
What problem does Minokawa solve?
At its core, Minokawa addresses the structural limitations that have historically constrained the development of private, trustworthy smart contracts. On most blockchains, both contract state and logic are fully transparent, which makes them rather unsuitable for applications that involve sensitive information, such as credentials, personal identity, private preferences, or proprietary business logic.
Minokawa changes this by introducing a contract model that natively supports private state and logic as well as public state and logic, so developers can now build applications where user data remains confidential and off-chain, while still exposing public data where necessary and providing cryptographic guarantees of correctness through integrated zero-knowledge proofs.
High-level diagram of Minokawa-enabled Midnight DApps
Traditionally, building with zero-knowledge required specialized knowledge of constraint systems, cryptographic tooling, and domain-specific languages. This has kept privacy-focused development out of reach for most teams. Minokawa eliminates these barriers by embedding ZK capabilities directly into a high-level, TypeScript-like language. Proof generation, circuit execution, and verification are all handled automatically at runtime, so developers can focus on business logic instead of cryptographic plumbing.
Rather than treating privacy as a static or global feature, Minokawa allows contracts to access dynamic, per-user private data through witness functions. This supports use cases that require evolving state while ensuring sensitive information is never exposed to the chain or other users.
Minokawa also supports hybrid logic that blends public and private workflows. Developers can write circuits where a user privately proves possession of a credential or satisfies a condition, and the contract then publishes a message or updates public state accordingly. These workflows are handled without manual encoding, proof wiring, or trusted setups, making advanced privacy logic far more approachable.
Minokawa architecture
Minokawa’s architecture consists of three tightly integrated pieces: the language, the runtime, and the compiler. Together, these components form a cohesive system for building zero-knowledge-native smart contracts on Midnight.
Underpinning the design is the Minokawa language, a statically typed, TypeScript-like domain-specific language (DSL) designed specifically for privacy-preserving contracts. With clear, expressive syntax, Minokawa allows developers to define circuits, manage public and private state, and access off-chain data through witness functions. Inspired by TypeScript, the language is statically typed and declarative, making it approachable for modern developers while enforcing correctness at compile time.
At its core, Minokawa distinguishes between circuits (functions that execute on-chain and generate zero-knowledge proofs) and witnesses (functions that run off-chain and access user-specific private data). This dual model allows for clear separation of public and private logic within the same contract. The language includes built-in support for complex types such as Bytes, user-defined enumerations, Vector, user-defined structures, and ledger-specific primitives like counters, sets, maps, lists, and merkle trees. Contracts are modular, supporting imports and reusability, and contracts rely on strong typing to ensure consistency across for both on-chain state and proof inputs.
The compiler is an implementation of the Minokawa language. It transforms Minokawa source code into a JavaScript module, TypeScript types, source maps, and zero-knowledge proof artifacts. These outputs are production-ready and optimized for frontend integration, enabling developers to build and debug privacy-first applications with minimal overhead.
Sitting on top of the language is the runtime, a JavaScript/TypeScript library that executes compiled contracts, manages proof data, and enforces runtime type safety. It provides the context in which circuits and witnesses operate, ensuring that data flows correctly between off-chain inputs and on-chain logic.
What does Minokawa enable?
In essence, Minokawa enables support for a new class of zero-knowledge-native smart contracts that combine privacy, verifiability, and usability in a single framework – unlocking advanced privacy use cases.
Selective disclosure
Unlike traditional blockchains where data is either fully public or fully private, Minokawa enables selective disclosure. Developers can choose exactly what information to reveal and what to keep private, supporting compliance and regulatory requirements without unnecessary data exposure. Disclosure of potentially private data must be explicitly allowed in Minokawa using the disclose keyword, reducing the risk of accidental leaks.
Advanced privacy use cases
Minokawa enables applications that require both privacy and verifiable integrity, such as private voting, confidential asset tokenization, decentralized identity/KYC, whistleblowing platforms, and private data marketplaces.
Get involved
As an LF Decentralized Trust project, Minokawa will evolve to become what it was intended to be all along: a public good, and a collaborative tool to help build the digital commons in which we live today.
The door is now open. We invite developers and enthusiasts, cryptographers and researchers, individuals and organizations of any size to join the community and expand Minokawa to serve its purpose.
Join us for a deep dive onto Minowaka and get started with the code and community at this Meetup on October 22 at 8:00 am Pacific:
