Notice: Polkadot has migrated to AssetHub. Balances, data, referenda, and other on-chain activity has moved to AssetHub.Learn more
ink! Alliance — PolkaVM Rust Smart Contracts on Polkadot Hub: ink! V6 Technical Delivery
Proponent: ink! Alliance (122VRdiHngKqsqqqVvTT2SZ3FN3BRFrupdYRaT7wuoZgkThd)
Date: November 2025
Requested Amount: $362,500 USDC
Category: Core Protocol / Developer Platform (Public Good)
Short description: This proposal delivers the engineering work required to make DOT programmable on the Polkadot Hub through Rust smart contracts. In response to the feedback from the Decentralised Voices and wider community, it focuses exclusively on completing, stabilizing, and audit-remediating ink! v6 for PolkaVM, and providing the example contracts, documentation, and tutorials needed for a production-ready launch.
Why ink! – TL;DR?
- ink! = Rust. If we want Rust smart contracts on the Hub, we need ink!.
- Polkadot-SDK is Rust. ink! gives Rust developers a low-friction, vertical path from contracts → runtimes → full chain development.
- 5.1M+ Rust developers. Enterprises trust Rust. That trust transfers directly into Polkadot’s smart-contract ecosystem with ink!.
- Rust = security, performance, smaller binaries, fewer bugs. ink! inherits all of that.
- Shared language = shared power. Polkadot-SDK and ink! both being Rust makes contracts ↔ runtime interaction more seamless.
- ink! is the only production-ready language for PolkaVM at Hub launch. Zero alternatives.
- XCM use-cases require ink!. Cross-chain logic is only realistically achievable with ink!.
- Rust ecosystem advantage. Massive ecosystem of crates, tooling, and integrations directly available to ink! developers.
- Rust is onboarding devs faster than Solidity. Data shows Rust’s Web3 growth is accelerating and is already comparable in size. https://forum.polkadot.network/t/rust-solidity-data-doesn-t-lie/15683
- ink! at Hub launch unlocks composability. Rust ↔ Solidity interoperability, XCM-enabled contracts, and system precompiles from the start.
- A strong Rust-native contract SDK drives the flywheel. More devs → more dApps → more usage → more DOT utility.
Overview
Context and Motivation
Polkadot Hub marks the next evolution of Polkadot, introducing dual-VM smart contract support for both EVM and PolkaVM, balancing short-term traction with long-term innovation. While EVM compatibility enables Solidity developers to deploy familiar dApps, PolkaVM represents Polkadot’s technological differentiation: high-performance, RISC-V-based execution, and future compatibility with JAM.
This proposal represents the fourth Treasury request (two rejected, but itemised for provenance as to the context of this proposal) related to advancing ink!, the Rust smart contracts SDK for the Polkadot Hub. Earlier Treasury funding (Ref. 1123) successfully delivered the foundational work for ink! v6 and PolkaVM readiness. A subsequent long-term bounty proposal and two follow-up Treasury proposals did not pass, based on feedback from ecosystem participants and the Decentralised Voices, this was largely due to concerns around scope size, structure, ecosystem alignment, and budgeting, all of which have been addressed in this proposal.
With the Polkadot Hub launch approaching, and PolkaVM requiring a production-ready contract language, this proposal focuses exclusively on the technical implementation and launch readiness of ink!, reflecting the feedback received on earlier submissions.
Previous proposals:
- Original Treasury proposal (delivered): https://polkadot.polkassembly.io/referenda/1123
- Bounty proposal (rejected by OpenGov): https://polkadot.polkassembly.io/referenda/1760
- Treasury proposal following the bounty (rejected by OpenGov): https://polkadot.polkassembly.io/referenda/1773
Feedback from previous proposals has been applied and an extensive FAQ is appended to this proposal addressing the most common questions and discussion points from previously submitted proposals (see appendix 8.2). This refined proposal focuses solely on the essential technical work needed to ensure ink! is stable, audited, and ready for Polkadot Hub adoption.
As an ecosystem we should prioritise our native technology and innovations to enable strategic advantages through differentiation and not mere imitation. ink! is the only language currently capable of bringing PolkaVM to market in 2025, begin testing it for JAM, and enable a market size of 5.1+ million Rust developers to use DOT programmatically in their applications. When smart contracts are enabled on Hub in December 2025, Solidity contracts will be deployed to the EVM side of it. For the unique strength of Polkadot – PolkaVM – there is no viable solution besides ink!.
ink! provides a secure, native Rust environment built directly on the Polkadot SDK, enabling developers to build advanced, composable, and cross-chain applications that leverage Polkadot’s unique interoperability through XCM.
This proposal funds the final push to bring ink! v6 to production, a release that will both showcase Polkadot’s unique technical edge and expand its developer base.
In terms of adoption, ink! v6 continues to see strong usage on the Hub’s testnet in relation to Solidity even though it is only in beta, with almost 1/3 of all smart contracts on PAsset Hub being deployed in ink! and 36% of all accounts related to ink!.
ink! also sees strong web traffic stats in terms of interest relative to the wider ecosystem. In addition to direct engagement on Telegram totalling 1237 messages and 71 active participants in the past 6 months.
Results from the Web3 Summit Hackathon in July ‘25, with ink! significantly taking the lead in terms of smart contract developer interest and hackathon project submissions:
Source: WebZero
This 6-month proposal funds critical technical development to take ink! out of beta, into production and enable Rust developers to build on the Hub directly:
- Audit remediation & stable release of ink! v6 on PolkaVM.
- Tooling, docs, benchmarks, and ergonomics improvements.
- Education (examples, guides, videos).
Full Proposal
The full proposal can be read here: https://docs.google.com/document/d/1TQ_cyWQlFW7PSjKPeSz9RSZax-xoA-aYmDgKJnu27NM
Comments (3)
https://polkadot.subsquare.io/referenda/1123
Let's be direct. Your last proposal referendum 1123 received significant treasury funding, justified by promises of documentation, developer onboarding, tools, and ecosystem growth.
So here is the only question that matters:
After all the funding was spent, which real, live and success products exist today that were built because of these deliverables?
Name the products. Who used your documentation to ship?
Hi @16UvcYx54zWfLQi4aWULXqmCL92RPe2uXopqy19LGRbwUbJa thanks for the question, it’s an important one, and it highlights a core misunderstanding about the current state of ink! v6 and the technical dependency on the launch timeline of PolkaVM on the Hub.
TL;DR
This proposal is the final step that enables the very adoption you are asking about, ink! v6 cannot demonstrate adoption without a production launch of PolkaVM on the Hub, which is imminent.
The critical dependency goes two ways: PolkaVM needs a smart contract language to use it (ink! v6) and ink! v6 needs PolkaVM to run. Adoption follows production, not the other way around.
If the Polkadot Community wants Rust smart contracts on the Hub, and wants PolkaVM to actually launch with a production-ready language that can use it, this proposal is the necessary and final technical piece in that puzzle.
ink! v6 is not in production yet.
It is in beta, and this proposal is precisely the final step required to take it into production, including audit remediation, stabilization, performance work, documentation, and onboarding materials.
So it is logically impossible to evaluate “product market fit” or “production usage” of ink! v6 before the product exists in a production-ready state.
To answer your question directly:
Q: “Which real, live, successful products were built because of the previous proposal?”
A: The previous proposal funded the foundational engineering work and migration from Wasm to PolkaVM, i.e. the infrastructure layer, not the launch of ink! v6 into production.
Therefore, no production applications could exist yet, because production use of v6 is not possible until the final technical work is complete. That is exactly what this proposal funds.
Expecting production adoption before the product is in production would be like asking: “Which JAM services are in production before JAM launches?”
The adoption curve begins once the tooling and language itself reach production.
What was delivered under the previous funding (Ref. 1123):
A full, itemized list of all delivered work is included in this proposal’s appendix (Appendix 8.1).
It’s also important to clarify that although proposal 1123 was funded for a 6-month period, the budget was intentionally stretched to cover over a year of development (October 2024 - November 2025 inclusive). This was done to optimise delivery while waiting for PolkaVM on the Hub to reach production readiness, a dependency outside the ink! Alliances' technical delivery control as it is a Parity dependency.
Now that PolkaVM is approaching its production launch on the Hub (source), ink! v6 is the only language capable of running on it. This proposal completes the final technical steps needed to bring ink! v6 into production so developers can actually begin building on the Hub using PolkaVM.
Why this matters?
ink! is Rust and Rust developers are driving Web3 adoption.
From Electric Capital’s 2024 report:
Full-time devs:
Rust ecosystems = 3,963
EVM ecosystems = 4,686
→ Practically equal, not “Solidity-dominated”
New developers (2024):
Rust ecosystems brought ~14,000 new devs
Ethereum + L2s brought ~10,000
→ Rust brought 30% more new devs than Solidity ecosystems
Rust-based smart contracts now make up 45.5% of the top-20 ecosystems, while 40.9% are EVM based.
Without ink!, the Hub launches EVM-only, losing a central part of Polkadot’s identity, and its ability to directly onboard Rust developers.
Read the full analysis: https://forum.polkadot.network/t/rust-solidity-data-doesn-t-lie/15683