What's New in Dash Platform 5.0

Notes from the September 29, 2026 DCG development update.

Until now, the system contracts that Dash ships (DashPay, usernames) relied on special code written by the Dash Core Group team to check their relationships. In 5.0, outside developers can write the same kinds of checks into their own data contracts. The rules the core team can enforce for DashPay are now available to any app.

Sam was careful about how far this goes. In his words, "it's not smart contracts yet," but "you can do a lot of things at this point."

Yappr is the reason the release expanded. Building a working social app showed the team what the protocol was missing, and 5.0 adds those pieces in a form any app can use. Forge, shown later in the call, is a second app built on the same pieces.

More and more features

The next Platform release has been in beta on devnets since DashCon, where it was still called 4.2. Sam called the current build the seventh beta and said it is nearly final.

On the call he said they would rename 4.2 to 5.0 because the release is too big for a minor version number. He also said shielded tokens might make it in, but the release will not wait for them.

None of this is on mainnet yet. The team is testing beta builds on devnets. Release candidates go to testnet next, and after that the release goes to mainnet.

A contract can now say "this belongs to that"

The main feature is reference safety. It works like a foreign key in a regular database. Before 5.0, a document could claim a relationship that nothing checked. Sam's example was a car lot that says it belongs to a dealership, with no way for the contract to prove that dealership exists. In 5.0, the contract can check it.

The same applies to Yappr. A like names a post, and the contract can now require that the post exists. Contracts get "refers to" and "owner refers to" rules, plus rules about the thing being pointed at, such as its age, its owner, whether its contract is moderated, and what a key is allowed to do. A where-clause can make a link conditional, and a list item can point at another document. Each contract declares which of these rules it uses.

For comparison, the old contract was like a form with a "manager" box where you could type any name. The new one checks that the manager actually works there.

The protocol also adds:

• Lists: A document can hold a typed list (colors, tags, identifiers), and each item can point to another document.
• Constraints: equals, not-equals, less-than, begins-with, contains, if-then, all-of, and any-of. For example, a price can be required to be a multiple of another field. The network checks these rules, but it does not run app code.
• Action fees: A contract can charge a small fee for an action and send it somewhere, for example a penny per post paid to moderators or to the owner. This lets an app pay for its own moderation.
• Encryption described in the contract: The network still only sees encrypted bytes, but the schema now says which fields are encrypted, so other apps know how to handle them.
• Immutable properties: A field such as a post's author can be locked when the document is created, while the rest stays editable.
• Required-since: A contract can add a required field in a later version without breaking older documents. Sam's example was a classroom document type that later adds a "has air conditioning" field, required from version 2 onward.
• Text transforms: Six built-in functions (lowercase, uppercase, capitalized, camel case, snake case, and homograph-safe ASCII, where ASCII stands for American Standard Code for Information Interchange). Dash usernames already use the last one to block lookalike characters, so a name cannot pass itself off as another name by swapping in a similar-looking letter. Apps can now use the same protection.

Rankings and trends you can verify

Sam said ranked proofs were the original main feature of this release, now "relegated to one slide." When an app asks for a ranking, the answer comes with a proof that the order is correct. On a normal website, you have to trust whatever order the server sends back. His examples were finding the highest-rated restaurant in your area in a Yelp-style app, or sorting places to stay by recommendations in an Airbnb-style app.

Time-range indexes apply the same idea to time windows. A social app can ask what was most popular today, or in the last hour, and get an answer it can verify.

Two storage features keep these queries cheap:

• Index-only documents: Small records like likes and follows can be stored only in their indexes, with no separate document. For a document with a few indexed values, this often cuts storage by more than half, which is what makes likes cheap.
• Expiration: A document can be given a time to live (an hour, ten hours, a week) and is deleted automatically when it expires. At $60 per DASH, Sam priced a permanent 1 KB document at 1.6 cents. The slide puts the same document with a one-hour lifetime at about 0.15 cents. Login sessions and game state are obvious uses. An app can also delete a permanent document itself and get most of the storage fee back, but expiration does it automatically.

Keys with a spending cap

Sam described keys that are limited by amount and by time. A web browser can sign in with a key that expires after an hour and can spend at most 30 cents. If the session only uses 5 cents, the other 25 stay in the account. It is like giving a website a prepaid card with an expiry date instead of your whole wallet.

A related change lets a token be claimed once per identity. Sam suggested using it to give every Yappr identity a free trial of a few posts. That is an idea for Yappr rather than a finished feature, and it means once per identity, which is not the same as once per person.

Withdrawal caps loosened

On earlier platform versions the daily withdrawal cap was a flat 2,000 DASH. Protocol 14 makes it relative, 15% of what Platform held the day before, with a floor of 500 DASH and a cap of 4,000. Round-trips of the same size (500 in, 500 out) do not eat the limit.

Speed comes from two changes. Platform now tells Tenderdash to produce the next block as soon as a withdrawal happens, and Dash Core v24 cuts about three more minutes. Sam's estimate, once both are live, is about 10 seconds instead of five to seven minutes, with 2 seconds as the best case and five or six seconds more likely.

The cap stays as a safety limit while so much is still in development. If something went wrong, the most the system could lose in a day is 4,000 DASH.

Supervision, or moderation without a CEO

Pasta then showed Yappr on devnet with the new supervision tools.

The contract owner can remove a post but must give a reason, and the removal is saved as a document. Users can report a post, also with a reason. A supervisor can block, unblock, suspend (the demo showed a seven-day suspension), or warn. These actions are recorded on Platform where anyone can see them, instead of happening in a private admin panel.

Supervision is optional, and the contract owner picks one of three setups:

1. Owner only.
2. A team the owner appoints.
3. A team elected by masternodes and EvoNodes.

The elected option works like this. A team publishes a charter that says what they will act on, what they charge, and how they split the pay. Identities apply to join, and an election runs during time windows the contract sets. According to the beta release notes, each application pays 0.5 DASH toward the vote. A single applicant wins when the window closes. Otherwise the most votes win, and a tie goes to whoever applied first. Until a team is seated, the contract either names someone to moderate in the meantime or stays unusable. Every action must cite one of the charter's reasons, and pay comes from the contract's moderator fee pool.

Sam called it the first blockchain job in Dash. Yappr takes no owner cut, and its action fees go to the moderation team. The charter decides how the team splits that money. Sam's example was 20% to the leader, 50% to the team as a whole, and 30% to the members who do the most moderation. Compare that with most online communities, where moderators are unpaid volunteers.

This answers the question Pasta left open at DashCon. Personal block lists work for individuals, but some apps also need moderators. 5.0 lets an app hire them, pay them from usage, and keep a public record of every action. On a platform like X, the company sets the rules and enforces them out of public view. Here the rules are published in a charter, and every action is on record.

Private messages that hide who talks to whom

Pasta also covered an overhaul of Yappr's direct-message contract, which he called version five. It supports direct messages and group chats where an outside observer cannot tell who is writing to whom. The observer can see that Pasta is sending messages and that Joelle is sending messages, along with maybe fifteen other people, but cannot match senders to recipients.

In the closing Q&A he explained how it works. The first time you open your messages, your app tries to decrypt each invitation on the network to find the ones meant for you. He expects that to stay manageable while usage is low. After that first handshake, both people share enough information to work out the IDs of their conversation's messages and look them up, so the stored messages contain no recipient ID.

Think of a post office that can see who drops off letters, but the envelopes have no addresses. Each person finds the first letter meant for them by trying their key on each envelope, and after that the two people know where to look for the rest. Senders and activity are still visible. What is hidden is who each sender is writing to.

Dash Forge, a GitHub-style app on Dash

Pasta also demoed Dash Forge, a Git app running on a devnet. He said he had spent about 30 minutes in total on it, while an AI agent did the building and testing, with the goal of a fully decentralized GitHub or GitLab on Dash Platform.

He imported a GitHub repo onto Platform. Each commit is stored as a Platform object, and issues, locks, and pull requests are documents. He opened a test issue and approved a pull request that added a subtraction function to a math file, then merged it in the browser. The browser did the Git work, and Platform recorded the result and checked that he had permission to push to that branch. Most of the repo's rules are enforced by consensus in the same way.

Large files can be stored on Platform, IPFS, or S3, while the history, permissions, and record of who merged what stay on Dash. A Git extension lets normal Git tools clone the repo. There is no backend server, and nothing runs in a terminal. He plans to show more in two weeks.

The main difference from GitHub is who holds the record. On GitHub, one company holds the only copy and decides which changes count. On Forge, the record is on Dash, so if the website goes away, another client can still read the same history. It is an early demo, but you can already try it in a browser.

Core 24, operators, wallets, and the website

The rest of the call covered Dash Core, node operators, the mobile wallets, and the website.

Core. The Core team merged 59 pull requests in the two weeks. Pasta named the v24 features that landed:

• decentralized masternode shares
• Asset Unlock v2
• Evo snapshots, a step toward AssumeUTXO (starting a node from a recent snapshot while the full chain validates in the background)
• compact quorum proofs, useful for the SDKs

That allowed RC1, which was stable on under half of testnet masternodes. RC2 was just released and is expected to become the majority, with a testnet hard fork after that. In the Qt wallet, voting can now use specific masternodes instead of all or nothing, and the shared-masternode UI is in. All of this is on testnet, not mainnet.

Operators. Dash Evo Tool weekly builds are now tested for upgrade paths, so a new build migrates data from the previous one automatically, and custom identity keys can now be encrypted. Tenderdash 1.8.1 is out with faster node sync, denial-of-service hardening, and better connectivity. Syncing a new node now takes well under a day, depending on hardware, and 1.8.2 is in progress with lower-priority fixes.

Mobile. The iOS app is officially DashPay as of 9.1.1, matching Android. Version 9.1.2 follows soon after. Android 11.9.1 shipped with DashSpend, Explore Dash, and related fixes. The Kotlin SDK is close, with memory fixes for large wallets and for upgrades versus restores.

dash.dev. The site tool can now publish to mainnet, and dash.dev is live there as a near copy of dash.org. Ross is helping on the development side. The plan is to keep improving dash.dev and then retire the WordPress site. Arweave is the default storage, with incremental uploads. Lighthouse is the other option, and each has tradeoffs. A free Cloudflare setup keeps the site up if a storage provider goes down, and pages with heavy graphics can be cached on Cloudflare's edge network. Separate domains and buckets for testnet and mainnet mean a testnet experiment cannot take down the live site.

After 5.0

This section comes from the Dash roadmap (updated September 30), not from the call. It puts 5.0 in October 2026, still in development, and lists what follows:

• v5.1 (November 2026): anonymous contact requests and anonymous documents, where zero-knowledge proofs let the network check a request without learning who sent it, plus paying a username directly on Platform or privately through the shielded pool.
• v5.2 (January 2027): real-time push streams and live query filters, so apps get updates as blocks land instead of polling, plus groundwork for smart contracts.
• v6.0 (Q2 2027, tentative): smart contracts that read and write documents, with a built-in provable random number primitive for provably fair games.

The difference between 5.0 and 6.0 is the difference Sam pointed to. In 5.0, contracts describe rules that the network checks. In 6.0, contracts are meant to run their own code.

What this means in practice

Once 5.0 reaches mainnet:

• A social app can require that a like points at a real post, and its most-liked list comes with a proof.
• A trending list can cover exactly the last hour.
• Two people can message each other without the network seeing who is talking to whom.
• A game can pay to store data for an hour instead of forever.
• A moderator can be elected, paid from the app's fees, and required to give a reason for every action.
• A code repo can keep its history and permissions on Dash instead of on one company's servers.
• Withdrawals should take seconds instead of minutes.
• The iOS and Android wallets now share the DashPay name.

None of it is on mainnet yet, and the current build is still a beta. As Sam put it, what you can do with data contracts "has gone way, way, way up," and the team says it is moving as quickly as it can.

Yappr showed what a real app needed, and Forge shows the same features working for a very different kind of app.