Crypto infrastructure, delivered and operated

Cryptuon turns a technical crypto requirement into a scoped, accountable delivery. Behind the service sit 20 open-source projects and published research — reusable technology we bring in only where it fits.

11
Problems we deliver against
20
Open-source projects
9
With reproducible public tests
6
Solana-native
MIT
Across the portfolio
Our Mission

The place a technical crypto requirement becomes an accountable delivery

Buyers come to Cryptuon with an outcome — a Solana launch, a data bill that is out of control, a validator migration that must not double-sign, a payment workflow that needs controls. We scope it with a paid assessment, agree acceptance criteria, assemble the technology and specialists, and deliver as the principal contractor. How engagements work.

The technology behind that service is a portfolio of 20 open-source projects across crypto, Solana, cross-chain, and developer infrastructure, published under MIT. Their maturity is stated publicly in the trust and maturity register.

The Solana subset is the largest single band of work — on-chain coordination for AI inference (SolanaLM), deepfake detection (DFPN), affiliate marketing (Njord), prediction markets (Mentat), indexing (StreamSync), and storage (SolanaVault). The rest of the portfolio spans cross-chain protocols (Tesseract, Switchboard), an embeddable EVM (Zig-EVM), compilers (SolScript, StxScript), and small focused libraries.

We build in Rust, Zig, Vyper, and Python because the crypto stack demands the same correctness, performance, and reproducibility guarantees as operating systems and databases. We publish under MIT because open standards win.

Portfolio shape

Networks

8 coordination layers

DFPN, Njord, StreamSync, Switchboard, Tesseract, SolanaLM, SolanaVault, DataMgmt Node.

Tokens

Tokenomics in 6 projects

EVMORE (21M PoW), DFPN (1B SPL), Njord (1B SPL), Tesseract (TESS), StreamSync ($STRM), Mentat.

Trading

4 trading & market projects

PolyBot (Polymarket / Kalshi), dgbit (Bybit), Moby Market (institutional DeFi), Sarpoy (Solana puzzle arena).

Tools

6 compilers, runtimes & libraries

SolScript, StxScript, Zig-EVM, nklave, blockchain-compression, commit-reveal.

How the technology is built

Independent projects, shared primitives

A portfolio structure is an unusual choice in crypto, where the default is to pick one protocol and pour everything into it. The reason it works here is that the products share primitives rather than users. Commit-reveal, staked operator reputation, hash-on-chain with payload off-chain, and Solana as a settlement and coordination layer show up across projects that otherwise have nothing to do with each other. Solving one of those once and reusing it is what makes twenty products tractable for a small team.

Each project is genuinely independent. It has its own repository, its own release cycle, its own marketing site at <name>.cryptuon.com, and its own documentation subpath. Nothing imports a shared Cryptuon runtime, and no project requires another to be deployed. That isolation is deliberate: it means a project can be adopted, forked, or abandoned without touching anything else, and it keeps every integration decision reversible for the people who depend on it.

The release discipline is shared even though the code is not. One tagged release publishes the marketing site, the documentation, and the binary together, so the docs a reader sees always describe the artefact they can download. We wrote up that pattern in Shipping Site, Docs, and Binary in One Release, because getting it wrong is the most common way an open-source project loses the trust of the people evaluating it.

Language choice follows the same logic. Rust and Zig for anything where a memory-safety bug becomes a consensus bug. Vyper where the contract surface should be small enough to read in one sitting. Python and TypeScript for SDKs, services, and tooling, because adoption depends on meeting developers in the ecosystem they already work in. The portfolio is multi-language because the problems are, not because we are undecided.

What we deliberately do not do

  • We do not put a token on everything. Six projects have on-chain tokens because a token solves a coordination problem for them. The compilers and libraries have none, and adding one would be a fundraising decision dressed up as a design decision.
  • We do not run closed betas. Every project is MIT-licensed and public from the first commit that works. Status labels distinguish what is production-leaning from what is still in active development, so the label does the job that a private repository usually does badly.
  • We do not publish benchmarks we cannot reproduce. Where a performance number appears on this site, the methodology is written down alongside it. Where we do not have a defensible number, we describe the mechanism and leave the figure out.
  • We do not build custodial products. Nothing in the portfolio takes custody of user funds as a business model. Escrow contracts hold value under rules that are public and enforced on-chain, which is a different thing entirely.
Leadership

Built by researchers who ship

DS

Dipankar Sarkar

Founder & CEO

Blockchain researcher and systems engineer with deep expertise in Rust, Zig, and protocol design. Author of 5 published papers on cross-chain composability, MEV mitigation, and DePIN protocols. Based in Scotland, UK.

Our Values

Principles that guide every decision

Rigor First

Every solution starts with formal analysis. We prove correctness before writing code, not after.

Open by Default

MIT-licensed. Open source drives adoption and trust. Proprietary lockin is a bug, not a feature.

Ship, Don't Simulate

Good ideas without production code are just ideas. We measure success by what developers can deploy today.

Interested in investing?

Cryptuon is building the infrastructure layer for multi-chain blockchain. We'd love to tell you more about our vision and roadmap.