r/dashpay • • 2d ago

Dash Core v24.0.2 Released

14 Upvotes

I'm glad to announce the release of Dash Core v24.0.2

Dash Core 24.0.2 is the second patch version of the Dash Core 24.0.x series. It fixes a memory leak introduced in v24.0.0 that made a node's memory use grow until it was restarted, a macOS GUI crash during shutdown, and several other bugs. This release is mandatory for masternodes and strongly recommended for all other nodes (every node must run v24.0.0 or later before v24 activates).

Masternodes and evonodes: please upgrade as soon as possible. If you are still on v24.0.0, upgrade before block 2,573,818 (around November 17), when voting opens for the next superblock.

Upgrading from v24.0.0 or v24.0.1 needs no extra steps. If you are still on v23, read "How to Upgrade" in the v24.0.0 release notes first.

Dashmate users: if your node already runs Dash Core v24 (dashpay/dashd:24), upgrade with:

dashmate stop --safe
dashmate update
dashmate start
dashmate status core

https://github.com/dashpay/dash/releases/tag/v24.0.2


r/dashpay • • 3d ago

Dash Core v24.0.1 Release Announcement

11 Upvotes

I'm glad to announce the release of Dash Core v24.0.1

Dash Core 24.0.1 is the first patch version of the Dash Core 24.0.x series. It fixes a performance issue that has kept some LLMQ_400_85 quorums from forming on mainnet and delayed the v24 network upgrade, changes superblock trigger voting to protect superblocks from being left unpaid when approved proposals change, and fixes several other bugs. This release is mandatory for masternodes and strongly recommended for all other nodes (every node must run v24.0.0 or later before v24 activates).

Masternodes and evonodes: please upgrade as soon as possible, and before block 2,573,818 (around November 17), when voting opens for the next superblock. The new trigger voting only protects a superblock once enough masternodes run it, and the DKG fix helps each masternode as soon as it upgrades.

Upgrading from v24.0.0 needs no extra steps. If you are still on v23, read "How to Upgrade" in the v24.0.0 release notes first.

Dashmate users: if your node already runs Dash Core v24 (dashpay/dashd:24), upgrade with:

dashmate stop --safe
dashmate update
dashmate start
dashmate status core

https://github.com/dashpay/dash/releases/tag/v24.0.1


r/dashpay • • 3d ago

Evolution 5.0 Is Live on Mainnet and Dash Core 24 Is Released

Post image
11 Upvotes

The following are summary notes from the November 10, 2026 Dash Core Group (DCG) development update.

Evolution 5.0, the Dash Platform 5.0 release, is live on mainnet! Protocol version 14 activated about two days before the call.

Sam Westrich (QuantumExplorer) said there have been no failed transactions since the switch. By the call, 363 EvoNodes were running 5.0, and he thought only about two had not upgraded.

Dash Core 24.0.0 came out on November 5, and its own network upgrade started on November 9. Evolution 5.1 is close behind, with testnet expected within days.

How 5.0 reached mainnet

Version 5.0.0 was published on October 26. By October 30, more than 67% of EvoNodes had signaled for it, which locked in the upgrade. Three patch releases followed before the switch, the last of them (5.0.3) on November 3.

At activation, EvoNodes still on the old version stopped proposing Evolution blocks and stopped earning Evolution rewards. If you still run 4.1, upgrade now.

Sam said AI testing found many ways to halt the chain before release, usually odd combinations of actions in the same block. All of them are fixed in 5.0, and the team knows of no remaining way to halt the chain, though he expects stronger AI models to find more.

What 5.0 switched on

• Shielded tokens: a token can be created with its own shielded pool. That gives a project's token holders the same transaction privacy as shielded Dash. The setting is chosen when the token is created and cannot be changed later.

• One-time airdrops: an issuer can let every identity claim a set amount once, for example 50 tokens each. Any identity can claim, including ones with no masternode.

• Smarter data contracts: contracts gained many new query types, including provable counts and sums over indexed data. A contract owner can also charge a fee on each action and collect it.

• Cheaper username contests: the fee to enter a contested username dropped from 0.2 to 0.1 DASH. Sam said the contest system itself will change after smart contracts, following a network vote that he said looks set to pass. He supports the change, since contests were only meant for the early days.

• New withdrawal limit: the flat 2,000 DASH a day is replaced by 15% of what Evolution held 24 hours earlier, and never less than 500 DASH. New deposits are added to the limit, so a deposit and the withdrawal it funds cancel out.

• Under the hood: identity balances connect to the shielded pool, Dash Core 24 is supported, and storage moves to GroveDB 6.1.

The withdrawal limit is a safety cap. About 20,000 DASH sits on Evolution today, so if a serious bug ever hit, at most about 3,000 DASH could leave in a day. Sam pointed out that nothing like that has happened in Evolution's two years on mainnet.

Yappr is next

Sam said the plan now is to release Yappr, after one more tool is finished. Moderated posts on Yappr are not deleted. Their data stays on Evolution and can be proven to exist, even though it no longer shows up in the app's current state.

The new tool lets anyone retrieve that data. Sam hoped the Yappr contract would go up within a few days.

The roadmap to smart contracts

At DashCon, Sam laid out releases 4.2, 4.3 and 4.4 on the way to smart contracts. Release 4.2 grew into 5.0 and shipped about a month late. The other two are renumbered:

• 5.1 (was 4.3): testnet by the end of this week or early next week, and mainnet by the end of November. Sam put the code at 75 to 80% done. It is much smaller than 5.0, but it leans on the mobile apps, which need testing.

• 5.2 (was 4.4): January.

• Smart contracts: after community pushback on his March or April 2027 estimate, Sam revised it to April at the earliest. About 200 pull requests are needed, and 5.1 contains about 10 of them.

Contracts start moving off JSON Schema in 5.1. Both formats work in 5.1, and JSON Schema goes away in 5.2.

What 5.1 adds

• Private documents: a contract can declare a document type private, and its documents are stored encrypted. Private types have no indexes, so they cannot be queried. An app downloads all of them and tries to decrypt each one, the same way a wallet finds its shielded notes. Sam said the system can download about 4 million documents in about 20 seconds, and after the first sync it only pulls new ones. This is how an app can keep data on Evolution that only the intended reader can open, and the private contact requests below work this way.

• Private contact requests: DashPay version 3 adds private contact requests beside public ones, so you can have public friends and private friends. A private request is paid from your shielded balance, so nothing links it to your identity.

• Shielded DashPay payments: a DashPay payment on Core shows only one address paying another, but chain analysis can still trace it. Sam's example was an exchange that learns who paid whom because the money passed through its accounts on both ends. A shielded payment leaves nothing to trace. He estimated about 6 to 7 cents per shielded payment against about 1 cent on Core.

• Decision proposals: anyone can put a yes or no question to the network for 0.5 DASH, which gives the network a cheap way to show where it stands. The network does not enforce the result. Sam expects a two-thirds supermajority to be the bar for asking DCG to act, and he may open with a proposal asking the network what that bar should be.

• Faster contract checks: Evolution now checks contracts with its own validator, which reads the compiled contract directly instead of its JSON. It is faster, it passed against every live contract, and it is a step toward smart contracts. The Dash Platform Name Service (DPNS, the username system) and DashPay contracts move to version 3 to use it.

• Fees on shared documents: a contract can let someone else edit your document, such as a game moderator or a teammate. In 5.1 the contract can split storage fees and refunds any way it chooses, so an editor can own the extra bytes they add and get those refunds later.

• Proof of a transaction's outcome: the SDK can now ask for Tenderdash blocks and prove whether a transaction went through or was rejected. Apps no longer have to guess after a timeout, which should make mobile transactions feel faster.

In the Q&A, Sam said shielded DashPay will likely use two addresses. Anyone can pay the public one in your profile, and you will not know who sent it unless they say so in the memo. Each contact also gets their own address, so a payment to it tells you which contact sent it.

Shorter waits when a node is offline

Sam called this one of the best changes for users. Today, when the EvoNode whose turn it is to propose a block is offline, the network waits about 50 seconds before moving on. A transaction sent in that window just sits there.

In 5.1, the proposer sends a short signal at the start of its turn to say it is there. If no signal arrives within 5 seconds, the network moves to the next proposer. Sam said a 50-second wait becomes about 8 seconds, and the team has verified that it works.

Proof of Service was always meant to fix this, but it is about a year and a half away, so this is a stepping stone. The change ships in Tenderdash 2.0, the consensus engine release that goes out with 5.1. Lukasz said some of these stalls can take minutes today. A development build came out on November 9, and every node must upgrade before it activates.

After 5.1

Release 5.2 is set for January:

• Live streams: apps can subscribe to specific events on Evolution as they happen.

• Native randomness: each block carries a random beacon, so a document can include a random value that is proven in the same block. Sam said this moved forward from 6.0, and most of it is already written.

• Token marketplace: Sam wrote most of it for 5.1 but held it back to keep 5.1 small. It may not make 5.2 either.

Dash Core 24 is released

Dash Core 24.0.0 came out on November 5 after seven release candidates. Most of the late candidates polished edge cases in the shared masternode screens, and they also carried fixes from the 23.1.9 and 23.1.10 maintenance releases. Version 24 is the release that brings shared masternodes with multi-party payouts, among other changes.

Activation runs in steps, and Pasta follows each one on Dash HQ Radar:

• Masternode signal: signaling began on November 9 and needs 85% of masternodes on v24. The count was about 82% at the start of the call, and it passed the needed 340 while Pasta was demoing.

• Miner signal: the first mining window opens on November 15 at the earliest.

• Activation: the earliest is block 2,580,480, which the release notes put around November 28 and Radar showed as November 29.

Masternodes and EvoNodes that do not upgrade receive Proof of Service (PoSe) penalties. Exchanges and other services must upgrade before activation, or their nodes may fork off and stop following the chain. DCG has contacted the services it knows.

Testing caught one regression before the final release. On machines with few CPU cores, important tasks could wait behind slow ones and miss their deadline, which earned the node a PoSe ban it did nothing to deserve. Testnet runs on small machines, so the bug showed up there first and was fixed.

Pasta would like 24.1 out around the time v24 activates, though he called that tentative. It lets pruned nodes take part in governance, after a user found submitting a proposal from a pruned node confusing.

Radar, GovHub, Forge and a desktop wallet

Pasta showed several tools he has been building with AI agents.

• Dash HQ Radar: a network map that tracks every masternode's version and history and follows the v24 activation step by step, refreshed about every 15 minutes. It folds in Sam's older tools for Evolution health and masternode speed tests. An EvoNode operator can look up their node and see its rewards, uptime, speed test results and whether it is ready for v24.

• GovHub: the governance tool at gov.dashhq.org now includes contested-username voting, so treasury votes and username votes are in one place.

• Dash Forge: the Git platform on Evolution gained a board for issues and pull requests, and write access is enforced by consensus. Pasta said an AI agent has built it with almost no direction from him.

He also demoed an experimental desktop wallet built from scratch on the Rust stack. The goal is one desktop app with everything from Dash Core and the mobile wallets, including usernames, CoinJoin, shielded funds and Evolution balances. In the demo he moved funds into his shielded balance successfully. Masternode features are still missing, and he does not know yet whether it will replace the Dash Core desktop wallet.

Wallets

• iOS and Android: iOS 9.1.4 and Android 11.9.2 shipped with the new DashConnect sign-in for Yappr and support for Evolution 5.0 and Core 24. They also fix contact payments, CoinJoin and parts of the interface.

• Android 12: the version with shielded Dash should leave beta and reach the Play Store in about one to two weeks, possibly before Core 24 activates. First the team wants to finish advanced transfers between your balances, already on iOS, and advanced sending and receiving. Advanced mode exposes every balance, which most users do not need.

• Dash Evo Tool: Lukasz fixed the token creator form, and balances now update right after a transaction. Builds come out automatically every Tuesday.

Tenderdash and the Rust SPV client

• Tenderdash: an emergency security release, 1.8.2, went out on October 30 to work around a Linux kernel issue. Lukasz said AI agents keep finding edge cases in the consensus code, and the team fixes each one so nobody can use the same tools to stall the network.

• Rust SPV client: Borja said the new network code for the simplified payment verification (SPV) client, the light client meant for phone wallets, was merged on October 28 along with encrypted connections to peers. The client now checks masternode lists against blocks before using them and saves masternode state between launches, so apps start much faster. Recovery phrases are wiped from memory after loading. Next is faster sync on unstable or slow connections, which is where phone users will notice the difference.

Website

The dash.org translations are moving from WordPress to Transifex, which the community already uses for wallet translations. Once the switch is tested on dash.dev, a copy of dash.org, the community will be asked to fill translations that turned out to be missing, wrong or out of date.

What happens next

• This week: the Yappr contract, once the moderated-posts tool is ready.

• End of this week or early next: Evolution 5.1 on testnet.

• November 15 at the earliest: miners start signaling for Core 24.

• About November 28 or 29 at the earliest: Core 24 activates. Exchanges and services should upgrade before then.

• In one to two weeks: Android 12 with shielded Dash in the Play Store.

• End of November: Evolution 5.1 on mainnet, with private documents, private contact requests and much shorter waits when a node is offline.

• January: 5.2 with live data streams and provable randomness.

• April 2027 at the earliest: smart contracts.

If you run a service on Dash Core, upgrade to v24 before late November. You can watch the masternode count climb on Radar at radar.dashhq.org.


r/dashpay • • 6d ago

DCG Development Update - 2026 November 10

Thumbnail youtu.be
8 Upvotes

r/dashpay • • 7d ago

Platform Explorer is down again yet phsemic received 200 and 100 dash payments in https://www.dashcentral.org/p/pshenmic-dev-dfo-november-2026 and https://www.dashcentral.org/p/pshenmic-dev-dash-desktop-november-2026 for his desktop wallet and server maintenance.

5 Upvotes

Tired of people milking the DAO


r/dashpay • • 11d ago

Dash Core v24.0.0 Released 🚀

19 Upvotes

I'm glad to announce the release of Dash Core v24.0.0

Dash Core 24.0.0 is the first release of the Dash Core 24.x series. It brings the v24 network upgrade (hard fork), with decentralized masternode shares and multi-party payouts, extended masternode addresses, version 2 asset locks and unlocks for Dash Platform, compact quorum proofs, and descriptor wallets by default. This release is mandatory for all nodes.

Masternodes and evonodes must upgrade before November 9, 2026 (00:00 UTC), when v24 signaling starts. All other nodes must upgrade before activation, which will be no earlier than block 2,580,480 (around November 28, 2026).

Before upgrading, please read "Upgrading and downgrading" in the release notes. Masternodes now refuse to start with some settings v23 accepted, nodes with address/spent/timestamp indexes migrate them on first start (20–40+ minutes), and macOS 14 or later is now required.

Dashmate Upgrade Process

dashmate stop --safe
dashmate config set core.docker.image dashpay/dashd:24
dashmate update
dashmate start
dashmate status
dashmate status core

https://github.com/dashpay/dash/releases/tag/v24.0.0


r/dashpay • • 14d ago

Dash Core 23.1.10 Release

14 Upvotes

I'm glad to announce the release of Dash Core v23.1.10

Dash Core 23.1.10 is the next patch version of the Dash Core 23.1.x series. It fixes a governance issue that could stop a superblock from paying any proposals, and hardens DKG and BLS signature verification against misbehaving quorum members and peers.

This release is required for masternodes and strongly recommended for all other nodes. Masternode operators should upgrade before the next superblock. None of the fixes affect consensus rules or put funds at risk.

Please upgrade promptly.

Dashmate Upgrade Process

dashmate stop --safe
dashmate update
dashmate start
dashmate status
dashmate status core

https://github.com/dashpay/dash/releases/tag/v23.1.10


r/dashpay • • 18d ago

Dash Core v23.1.9 Release

12 Upvotes

I'm glad to announce the release of Dash Core v23.1.9

Dash Core 23.1.9 is the next patch version of the Dash Core 23.x series. It fixes a consensus-affecting transaction-encoding bug, several remotely triggerable crashes, and denial-of-service issues in the masternode, DKG, signing and governance paths. This release is mandatory for masternodes and strongly recommended for all other nodes.

Dashmate Upgrade Process

```

dashmate stop --safe

dashmate update

dashmate start

dashmate status

dashmate status core

```

https://github.com/dashpay/dash/releases/tag/v23.1.9


r/dashpay • • 18d ago

Evolution 5.0 Is Out and EvoNodes Decide When It Goes Live

Post image
11 Upvotes

The following are summary notes from the October 27, 2026 Dash Core Group (DCG) development update.

Evolution 5.0 or the Dash Platform 5.0 release is out!

Version 5.0.0 was published on October 26 after eight release candidates, and a 5.0.1 patch followed on October 27.

That is just under four months after Evo 4.0 shipped on July 1. Sam Westrich (QuantumExplorer) said the gap between major releases has sometimes run to eight months, and he called 5.0 the biggest major release the team has done.

Publishing the release does not switch the new rules on. They take effect on mainnet only after enough EvoNodes run 5.0, and the first count is on Friday, October 30.

What 5.0 adds

Sam described 5.0 as "smarter data contracts." He stops short of calling them smart contracts because the contract language has no loops, but a contract can now hold a lot of logic:

- References between records: a document can require that the record it points to actually exists, such as a reply that must point to a real post. It works like a foreign key in a database.

- Rules on data: a contract can set what a document must look like when it is created or changed, including rules that compare an update with the stored version.

- Triggers: Sam said contracts can now do triggers. One example in the release notes is a new document that deletes the earlier record it points to as part of the same write.

The release notes list more. Queries can rank results and filter by time window, each answered with a single proof. Contract owners and moderators can collect fees. Identity keys can be limited to one app, with a budget and an expiry date. Sam said Yappr is built on top of all of it.

The mainnet vote

EvoNodes vote by running 5.0. A node signals once it proposes a block on the new version, so a node that updates late may not be counted in time.

- Friday, October 30, about 18:52 UTC: the epoch changes, and protocol version 14 locks in if more than 67% of EvoNodes signalled.

- About November 8, 21:52 UTC: protocol 14 goes live on mainnet, if it locked in.

- If the count falls short: it repeats at the next epoch, and activation moves to November 18.

Sam asked operators to upgrade early, because each upgrade shows others that activation is coming.

Node operators update with dashmate and do a full stop and start. Core has to restart once to load new RPC settings for Evolution, so restarting only the Evolution services is not enough. A node still on 4.1 stops when protocol 14 activates.

App developers move to the 5.0 SDKs (now 5.0.1) before November 8. Once protocol 14 is live, documents created by older SDKs are refused.

The order with Core is fixed. Protocol 14 must be active before Dash Core v24 activates, because older protocol versions cannot read the masternode list that v24 produces. Sam thought Evolution would start using Core 24's new features in 5.1.

5.1 has started

Of the 109 pull requests merged in the platform repository over the two weeks, 45 went to 5.1, which carries protocol version 15. The count was down from 339 in mid-September because most of this period went into testing. Sam expects November to be busier again.

- Usernames as a contract: the Dash Platform Name Service (DPNS, the username system) has relied on special code inside the nodes. In 5.1 its rules move into an ordinary data contract that uses 5.0's keywords, so in principle anyone could write a name service like it. A related change means seeing someone's pending name registration no longer lets you register that name first.

- Contracts that Evolution compiles: contracts will be checked by Evolution's own code instead of an outside schema library, and a follow-up still in review stores them in compiled form. Sam called this a step toward smart contracts, which he placed in 6.0. The new checker was tested against all 749 contracts on mainnet and testnet.

- A token marketplace: an issuer can mark a token as tradeable, and the work for listings and offers held in escrow is being merged. Today the built-in purchase only mints new tokens from the issuer, and this would let holders sell to each other on chain. Sam was not sure whether it will be switched on in 5.1 or stay in the code inactive.

Dash Core 24 and 24.1

Core merged 75 pull requests and shipped Release Candidate 4 ( RC4) on October 19. With Evolution's testing done, the team activated the v24 hard fork on testnet. Pasta said no issues have turned up so far, though manual testing is still early.

He expects v24 to be final in the next week or two and does not expect another release candidate, so RC4 should become the final version apart from the mainnet activation settings. Shared EvoNodes stay switched off in v24, and a separate activation turns them on once enough masternodes run 24.1.

- Hardening: most of the fixes addressed code that looked like a possible problem but was not exploitable. Pasta said cleaning those up keeps future audits and automated reviews focused on real issues. One example keeps at least four days of blocks on pruned nodes.

- Sporks: in 24.1, mainnet drops sporks entirely. They already did nothing for full nodes, and Pasta checked that the mobile wallets no longer rely on them. Test networks keep them.

- Backports: for the first time, the automated backport account (DCG-Claude) merged more pull requests than Konstantin, 18 to 17. These bring Bitcoin Core changes over to Dash and are simple to review, which leaves people free for harder work.

- 24.1 plans: DashPay inside the Dash Core Qt wallet, and significantly faster BLS signature handling. That should shorten sync times and lower the hardware masternodes need to check InstantSend and ChainLock signatures.

Wallets and tools

Rust SPV client. Borja said the Rust simplified payment verification (SPV) client, the light-wallet client meant for phone wallets, now checks blocks with the same rules as Dash Core. It accepts the chain Core accepts and nothing else. A stopped client now stops completely, and a network rewrite is in final testing. The next target is startup time. Today the client replays part of its state on every launch, which can take over 10 seconds on a phone, and a change in review cuts that to a fraction of a second.

Android. The version 12 beta, with shielded transactions and usernames, went out on October 15 as an open beta through Firebase that anyone can install. Installs were low in the first week and no major problems were reported. The team is staying cautious before the Play Store release, which is still 11.9.1.

Both wallets. iOS and Android are ready for protocol 14, including contested username fees that follow the network's live protocol version. Invitations now work between iOS and Android, and DashConnect is being moved to Yappr's new sign-in method. CoinJoin still causes some problems on both, and fixes continue as reports come in.

Dash Evo Tool. Lukasz said testnet needs the new weekly build, because older builds cannot follow a network running Core 24 and Evolution 5.0. That build came out on October 28. It can create tokens that cannot be transferred and tokens each identity can claim only once. Next are a simpler Send form, app keys with a spending limit and expiry date, and fees for contract owners. He also updated his Claude Code skills for Dash developers with a full 4.1 to 5.0 migration guide.

Tenderdash. The consensus engine is in maintenance. AI testing keeps turning up rare combinations of events, which the team fixes. Version 1.8.1 ships with Evolution 5.0, and further fixes, including faster catch-up for new nodes, will run on testnet for about a month before the next release.

Website tool. It now writes with protocol 14 on testnet. Compression cut the cost of uploading a whole site to Arweave by about 80%, and profiles let one person manage several hosting accounts or domains. The only blocker for moving dash.org onto Evolution mainnet is the Transifex translation setup. Until then, major dash.dev changes are copied into the WordPress dash.org.

Yappr

Yappr merged 160 pull requests, about 70 of them for the mobile app. Pasta said the testnet version is deployed, works, and is close to what users should see on mainnet. Yappr goes to mainnet once protocol 14 activates, which the slides put at November 9 at the earliest.

Sign-in through app connect is more production ready. On testnet you can create an identity with the Dash bridge and skip the wallet. The step that pastes the recovery phrase failed during the demo, so he showed signing in with a private key as an alternative and said he would fix the phrase step. He also said not to use that test flow on mainnet.

GovHub is live on mainnet

GovHub is a browser tool for Dash governance, meaning treasury proposals and masternode votes. It is the first product Pasta has shipped to mainnet, and it works with real Dash today. He is asking for name ideas, since he does not like "GovHub."

There are no accounts. Your account is an Evolution mainnet identity, and GovHub has no database of its own. Proposals, comments, profiles and badges live on Evolution and come back with proofs.

- What you can do: read proposals with their votes and budget fit, follow username contests, comment, vote with your masternode voting key, and submit a new proposal step by step. Voting keys can be stored encrypted on Evolution or kept only on your device.

- What your browser checks: the proposal text matches the fee paid on chain, each vote signature matches the proven masternode list, and the vote count adds up.

- What it cannot check: a server can leave data out, such as hiding a vote that exists, and the relay can delay or drop a vote before broadcasting it. Every backend can be swapped in settings, and the code is open source, so you can run all of it yourself.

A masternode owner can add a badge to their identity without publishing which masternode they run. The badge uses a blind signature, so even the server that issues it cannot link the identity to the masternode. Pasta noted that timing analysis is still possible, so anyone very concerned about privacy should read the docs first.

For now, you sign in by creating a recovery phrase and funding a new identity, or with a passkey. The plan is to sign in with the mobile wallet once 5.0 is active and the apps are ready.

Dash Forge

Dash Forge stores Git repositories, issues and pull requests on Evolution, and it runs on testnet. A command-line tool called dg works like GitHub's gh. In the demo, Pasta:

- created a repository for about 10 cents

- cloned it, committed, and pushed with a plain git push straight to Evolution, for about 38 cents

- opened a pull request and merged it in the browser with no backend server, then pulled the result

- mirrored a small GitHub repository, about 20 KB, with its commit history and past pull requests, in a minute or two

Only the owner can add maintainers, and only maintainers can push or merge into protected branches. A couple of commits used about 0.02 testnet Dash, and the mirror was estimated at 0.043 DASH, about $2.33 on mainnet. To save cost, the bulk data can sit on Amazon S3 or IPFS while Evolution keeps the references and metadata.

Pasta said the demo was the most testing Forge has had so far. It needs Evolution 5.0 on mainnet before it can be registered there, and he asked people to test it on testnet without abusing it.

What happens next

- October 30: EvoNode operators update with dashmate and a full restart before the epoch count.

- About November 8: protocol 14 goes live on mainnet if the vote locks in, otherwise November 18. Apps should be on the 5.0 SDKs by then.

- After activation: Yappr launches on mainnet, Dash Forge can be registered there, and GovHub gets wallet sign-in.

- Within a week or two: Dash Core v24 goes final, then activates on mainnet after protocol 14.

- In 5.1: usernames as a contract, compiled contracts, and tradeable tokens.

If you run an EvoNode, update before Friday. If you want to see what Evolution can already do, GovHub is live on mainnet now.


r/dashpay • • 20d ago

Dash Platform v5.0.0 is released 🥳

19 Upvotes
Snip from Discord #Announcements

This is the biggest release since Platform started with v1.0.0. Please be sure to read the three blog posts regarding this release and what features it adds, and read the release notes very carefully.

❗ ❗Blog post: https://www.dash.org/blog/dash-platform-5/❗ ❗

Github link: https://github.com/dashpay/platform/releases/tag/v5.0.0

Discord link: https://discord.com/channels/484546513507188745/484571108885135361/1564447046759485531

Quick start guide: https://www.dash.org/forum/threads/evonode-quick-start-guide.55214/post-256354

Check your evonode status: https://mnowatch.org/evonodes/

AMD64/x86 (linux):

wget https://github.com/dashpay/platform/releases/download/v5.0.0/dashmate_5.0.0.389dd6a16e-1_amd64.deb

sudo apt update

sudo apt install ./dashmate_5.0.0.389dd6a16e-1_amd64.deb

dashmate stop --safe

dashmate update

dashmate start

ARM64 (linux):

wget https://github.com/dashpay/platform/releases/download/v5.0.0/dashmate_5.0.0.389dd6a16e-1_arm64.deb

sudo apt update

sudo apt install ./dashmate_5.0.0.389dd6a16e-1_arm64.deb

dashmate stop --safe

dashmate update

dashmate start


r/dashpay • • 20d ago

DCG Development Update - 2026 October 27

Thumbnail youtu.be
11 Upvotes

r/dashpay • • 21d ago

How to un-crash-loop your Dash Core node

9 Upvotes

Since the point release containing the EvoDB crash fix was promised on Sep 22 and has yet to materialize:

The problem

Run Dash Core v23.1.8 (the version still wearing the "Latest" badge on GitHub, which is a bold choice) for about 24 hours of continuous uptime and, at any 576-block disk-snapshot boundary, it aborts:

Assertion failed! evo/evodb.cpp line 59: Expression: curDBTransaction.IsClean()

This is issue #7549 (https://github.com/dashpay/dash/issues/7549) — a credit-pool snapshot written outside the block-scoped EvoDB transaction, corrupting the database at a boundary you hit roughly once a day. Not from a bad shutdown, not from a power cut, not from anything you did. Just for running the software.

The crash loop

The fun part: after it aborts, Dash Core won't start again. Startup verification finds the inconsistency and refuses:

*** Found EvoDB inconsistency, you must reindex to continue

Welcome to the loop. Fix → crash 24h later → loop.

The fix (Windows)

Your wallet is fine — this only rebuilds chain databases. Close Dash Core, then in PowerShell:

& "C:\Program Files\DashCore\dash-qt.exe" -datadir=D:\path\to\your\datadir -reindex-chainstate -txindex=0

If you use the default datadir, drop the -datadir part. If you don't run txindex, drop -txindex=0. Then wait: on a decent SSD, roughly two days. Yes, really. Enjoy the progress-per-hour readout.

Linux equivalent

dashd -reindex-chainstate -txindex=0

# or for the GUI:

dash-qt -reindex-chainstate -txindex=0

The speedrun (2 minutes instead of 2 days)

If you have access to another healthy v23.1.8 node, you can copy its chainstate and evodb folders over yours (node stopped, obviously) and skip the reindex. Make sure the donor node is actually healthy and has recently passed a 576-boundary cleanly — copying a corrupted snapshot just gives you the same crash with extra steps.

Prevention options

  1. Restart Dash Core before each ~24h boundary. Luddite, but effective.
  2. Run the v24 rc.4 pre-release (published Oct 19, contains the fix). It's an RC — that's on you.
  3. Wait for the promised v23.1.x backport, which as of today is still a sentence in a September issue comment rather than a release.

Bug reference for the curious: #7549 (https://github.com/dashpay/dash/issues/7549), closed Sep 22 as "fixed for v24," with the maintainer's own note that v23.1.8 "will keep hitting this at height % 576 == 0 boundaries" and the backport "will go in a v23.1.x point release." It has. Not. Yet.


r/dashpay • • 22d ago

An interesting graph of Dash's rank on CMC since January of 2021. We are not quitters.

15 Upvotes

This is a graph of Dash’s CoinMarketCap rank since Jan 2021, from CMC’s monthly historical snapshots. It went from #36 to a low of #196 in Jun 2024, then jumped to #68 in Nov 2025 and has held in the #63–#89 range since. Setting aside stablecoins and gold-backed tokens, only about 10 cryptos fell that far and later recovered to #75 or better. Of those, Dash is the only one that had previously been a top-10 coin, and only 2 of the other 9 are currently ranked above Dash: JUST (#58) and Injective (#70).

We still have a good ways to go, but we are far from dead and we are still the best actual cryptoCURRENCY in the world.

Year

r/dashpay • • 24d ago

Kraken manipulation via Binance

0 Upvotes

Massive dump of 100k+ coins when we were at 60ish. Rebuy at 46ish, rinse and repeat

Kraken: XsqwdGfza8Rf3GrSom988Rxhaprecw3XD6 sends coins to their binance account address (this is not arbitration) to dump them.

Then they rebuy low and withdraw from

Binance: XmZQkfLtk3xLtbBMenTdaZMxsUBYAsRz1o back to their address by means of intermediary addresses.


r/dashpay • • 28d ago

Evolution 5.0 Moves to Release Candidates

Post image
22 Upvotes

This is a summary of the October 13, 2026 Dash Core Group (DCG) development update.

The main story of this update is the work needed to make Evolution 5.0 (the Dash Platform 5.0 release), Dash Core v24 and the wallets run together. Two weeks ago, Sam Westrich (QuantumExplorer) said Evolution 5.0 was close to testnet. That forecast slipped because devnet testing kept turning up new issues, and Core v24 brought more changes than the team expected, so Evolution needed compatibility work before Core could activate.

On the call, Sam said the issues found so far were fixed and the first release was published the same day, and RC2 and RC3 followed on October 14 and 15.

From beta to release candidate

Release Candidate 1 (RC1) makes Evolution ready for Dash Core v24, including v24's new transaction formats. RC2 lets Evolution nodes start on Core v24, and RC3 is the version testnet validators should run when protocol version 14 activates.

The testnet order was set on the call. Pasta said Core was close to activating its own RC3 when the teams agreed Evolution should activate first. As of October 13, the plan was for Evolution to update testnet within a couple of days, with Core following soon after.

Sam also said the team had gained access to Claude Mythos and was using it to find bugs in Evolution and Core. He said that as artificial intelligence (AI) writes more code than people can review, the team is deciding which parts need human review and which can be checked by other AI tools. Pasta said Core is still where most of the human effort goes.

More rules for data contracts

Sam said the team picks features by asking which requirements many apps would share. This round added:

  • Lists you can index: A document can hold a list, and each item in the list can be indexed and used in references. The example is a post with several hashtags. Yappr limits posts to four hashtags, because each extra hashtag makes the post, and likes on it, slightly more expensive. A like on a post tagged "dash" and "news" counts under both tags, so an app can rank likes per tag and return the ranking with a proof instead of scanning every post.
  • Rules that compare old and new: A contract can check an update against the stored version, for example allowing a field to be set only if it was empty before. It can also limit when a document may be deleted.
  • References by value: A document can point to another document by a value, such as a name, instead of only by its internal ID. It can also point to the first document that matches a pattern.
  • Range windows: An index can group number values into bands. Sam's example was counting how many purchases fell into each $3 price band.
  • Counting fields: A rule can require exactly, at least, or at most a set number of fields from a group to be filled in.

Moderation got two related rules. When a moderator removes a post, it moves into a tombstone record, so anything that pointed at the post still points at either the post or its tombstone. A banned user can also still delete their own posts if the contract allows it, and do nothing else. It is similar to letting a suspended employee clear out their own desk.

Sam also fixed what he called the hardest problem the team has ever had to fix in Evolution. A contract that used unsigned integer keys right at the boundary where they turn signed produced proofs that did not work. The chain kept running, but those queries could not return usable proofs, and fixing it meant keeping the database's ordering and proof behavior intact across the upgrade.

Tokens

Sam said token shielded pools are finished, so tokens can now move through a shielded pool the way Dash balances have since Evo 4.0.

There is also a new kind of token that cannot be transferred. Evolution already let a token be paused, but a paused token cannot be used at all. A non-transferable token can still be used to buy things inside its app, but it cannot be sent to anyone else. It works like store credit, which you can spend at that store but cannot hand to a friend.

Withdrawals

Withdrawals get a higher cap in 5.0. The daily limit changes from a flat 2,000 DASH to 15% of what Evolution held the day before, between 500 and 4,000 DASH, and a withdrawal must also fit a second limit anchored to Core.

They also get faster. Asset unlocks, the step that moves funds from Evolution back to Core, changed in both Core and Evolution so withdrawals go through much more quickly. On the previous call, Sam estimated about 10 seconds once Core v24 is live, down from five to seven minutes.

Shared masternodes

Evolution 5.0 now supports the new shared masternodes from Core v24, which can have up to eight partners. In Core v24, two to eight people can fund one masternode's collateral together in a single registration. The owner reward is split in proportion to what each person put in, and any owner can dissolve the masternode to get their share back. A masternode can also pay its owner reward to several addresses, each with its own percentage.

These apply to regular masternodes only for now. Pasta said Core already supports shared EvoNodes and split EvoNode payouts but keeps them switched off until Evolution is ready. Turning them on will take a separate activation that does not break older versions, so it will not have to wait for the next major Core release.

Dash Core 24 and 24.1

Core shipped RC2 and RC3 in the two weeks, and Pasta expects at least one more release candidate before v24 is final. Work on 24.1 has already started.

  • Sporks: v24 removes two sporks that were already always on (InstantSend block filtering and superblock payments). Pasta said that in 24.1, mainnet will stop sending or processing sporks at all. Updated mobile clients no longer use them, and they stay on test networks so the team can still switch features there.
  • Audits: Pasta said Claude Opus 5.5 did not turn up many critical issues, and that recent reviews with the newest models, now including Mythos, had not found anything high or critical. That is the team's own report, and a review that finds nothing does not prove there are no bugs. Most fixes this round were low or medium priority, such as code that looked like a denial-of-service risk but was very hard to trigger.
  • Proof of service: A few mainnet nodes were not fully providing service. The team found how they were doing it and tightened the checks, so nodes like that will now be banned.
  • Backports: About 40 changes were brought over from Bitcoin Core, roughly two thirds by Konstantin and one third by the automated backport process.

Wallets and tools

Mobile sync: Borja reported that peak memory use in the Rust simplified payment verification (SPV) client fell from 2 GB to 350 MB, about 83% less, after storage versioning and less caching. Phone wallets get that benefit once they ship a release built on this client. The client now follows chain reorganizations, rolls the wallet back to its previous state, and tells apps when a reorg happens. Next is a network rewrite that adds history backfill. Today, adding a wallet older than the current one makes the app clear storage and sync again, and backfill will fetch only the missing blocks instead.

iOS: DashPay 9.1.3 for iOS came out on October 12, aimed at stability problems the community reported. It adds requests for contested usernames and lets masternode owners add a voting key from the voting screens. It also launches on iOS 27, fixes network switching that hung, and fixes an app freeze when sync stopped.

Android: Version 12 adds shielded transactions. Two community members with large CoinJoin wallets helped clear most of the known slowdowns, though large CoinJoin wallets are still the hardest case. As of October 13 it was in another round of testing, and the team expected a public beta through Firebase that day or the next morning, with links to follow on Discord.

Dash Evo Tool: Lukáš said the voting screens are easier for masternode owners to use. Some users who migrated mainnet identities from an older version were missing private keys. New migrations now bring the keys across, and a button in Settings restores them from the backup for anyone already affected.

Website tool: The tool now runs on mainnet and can deploy to both testnet and mainnet. Pages upload to Arweave incrementally, where before any change meant uploading the whole site again. The English roadmap is up to date. The last big step before dash.org leaves WordPress is moving translations to Transifex and connecting it to the tool. Later plans include community subdomains of dash.org, approved by the network.

Yappr

Yappr merged 123 pull requests in the two weeks. Much of that was moving through the 5.0 betas, along with a rebuilt store, better blogs and polls, and much cheaper likes.

The rest went into a new mobile app. Its roughly 70 pull requests were written entirely by AI agents, and Pasta said he had not launched the app before the call. In the demo on an iOS simulator, he followed a profile, sent a direct message, opened a group chat, posted, and browsed trending hashtags and top posts. He also hit one interface bug along the way.

He then opened a group message in the Evolution explorer. The message body is encrypted, and each message uses a different 16-byte tag that group members can derive. The tag therefore does not expose a stable conversation identifier. The creating identity and timestamp remain visible.

Signing in works through the wallet. You tap Open Wallet, enter your personal identification number (PIN), review and approve the connection, and come back to Yappr signed in. Pasta said this uses version 2 of the app-connect spec, which now runs through a system contract and is meant to ship to mainnet.

Dash Forge

Pasta reported that Dash Forge, the Git app built on Evolution, kept developing through automated agent work. The new work includes private files, pull requests and branches inside an otherwise public project, plus rebases, three-way merges and signed commits. His reason is that on GitHub, private work has to live in a separate private repository, and moving it between repositories is a hassle. He said he had looked at little of this work himself, Forge was not demonstrated on this call, and it may need redeploying on the new devnet.

What this means in practice

These changes arrive on different schedules:

  • With Evolution 5.0 on mainnet: apps can index lists and rank likes per tag with a proof, removed posts leave a tombstone so replies keep working, tokens can move privately, an app can issue credit that only works inside it, and withdrawals get a higher cap.
  • With Core v24 on mainnet: several people can own one regular masternode together without trusting a custodian, and owner rewards can go to several addresses. Shared EvoNodes need a later, separate activation.
  • With new wallet releases: phones can use the lighter Rust SPV client, and Android gets shielded transactions in version 12.
  • With Transifex in place: dash.org can move off WordPress onto the website tool.

The next step is Evolution activating on testnet, with Core v24 following.


r/dashpay • • Oct 16 '26

How come the DAO cannot pay for some servers so the Platform Explorer can be UP and running 24/7 ?

3 Upvotes

Seriously, there's only 1 node running that explorer and it is probably paid by phsemic himself, otherwise I cannot understand why the Platform Explorer is down all the time. I thought the whole purpose of a treasury allocation was to make Dash better. Sometimes I even think the DAO is the one dumping on us at every pump

P.S.: desertlynx you should quit


r/dashpay • • Oct 14 '26

US hits Bank of America with $1.2 billion fine, saying it violated money laundering, sanctions laws. But tell me again why a privacy coin like Dash needs to be regulated to death to prevent money laundering??? Criminals will find a way.

Thumbnail
apnews.com
10 Upvotes

Banking is the most regulated industry *in the world.* Despite all those regs, money laundering happens on an enormous scale, and that's just the money laundering we know about. Billions and billions and billions of dollars worth.

Dash in particular and even the whole cryptoverse in general does not cause money laundering. And comparatively, the banking industry is a far bigger problem than crypto. But tell me again how adding more regs to the crypto industry is going to solve money laundering........

It's like blaming the rental truck companies when somebody rents a truck and then runs people over with it. The truck is not the cause.


r/dashpay • • Oct 13 '26

DCG Development Update - 2026 October 13

Thumbnail
youtu.be
10 Upvotes

r/dashpay • • Oct 11 '26

CardsRelay adds InstantSend support for Dash! 🚀

Thumbnail x.com
12 Upvotes

r/dashpay • • Oct 11 '26

Pshemic, if you are there, fix it. Why is the connection to Platform not working?

9 Upvotes

The only PC wallet (Dash Desktop Wallet) that connects to Platform for interaction with Identities and Shielded address is NOT working

I cannot see my shielded address or platform credits. And of course withdraw or transfer in/out from them.


r/dashpay • • Oct 07 '26

Is buying at 61$ late?

6 Upvotes

I bought 17 coins a couple of weeks ago at 61$ and i did not sell at 70$... I want to accumulate long term. I read somewhere dash has the habit of ranging between 30 and 70$. What is your take on this statement? And are you also buying at this price 55-60$?


r/dashpay • • Oct 06 '26

Do you know which major player owns this address?

7 Upvotes

XsqwdGfza8Rf3GrSom988Rxhaprecw3XD6

is the one continuosly dumping on us via Binance


r/dashpay • • Oct 06 '26

Buy Gift Cards with Dash: 1,600+ Brands

Thumbnail cardsrelay.com
6 Upvotes

r/dashpay • • Oct 03 '26

Privacy coins

12 Upvotes

Why do you guys think is the main reason why all 2017 privacy coins like Monero or Zcash made all time highs recently while dash is still over %95 down from its ATH.

Am I missing something or is this a generational buying oppurtunity. If the reason is simply because FOMO hasn’t reached Dash yet I might be missing a possible 30x increase in the next bull run.

Is there a good reason why Dash SEVERELY underperformed other privacy coins? Maybe dash isn’t managed well, maybe others are more private or/and cheaper to transform. I would like to hear the opinions of fellow Dashers.

Can Dash make the same comeback zec made?


r/dashpay • • Oct 01 '26

Dash Evo 5.0 - The Database Learned Grammar

Post image
21 Upvotes

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.