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.

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

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.

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.

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$?

XsqwdGfza8Rf3GrSom988Rxhaprecw3XD6 

is the one continuosly dumping on us via Binance

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?

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.

I have blanked out the DashCon stuff as that's not related, and sorted the list by newest first. Notice that the most recent review is only a couple days old, but already has 490 views (the most), the previous one, has 400 views and the ones before that are about an average of 250 views.

This shows a couple of things.

1) Post DashCon, interest in Dash has been piqued.

2) Strong end of year Seasonals for Dash are bringing more eyes onto the project.

3) The development is strong and creating more interest among viewers. 👀

https://www.youtube.com/@DashOrg/streams

Hi everyone,


I've built 
Crypto Masternode Monitor
, a free Android app that watches your masternodes and notifies you when one drops, and again when it recovers. No account, no ads, no tracking, and it never asks for a private key.


Website:
 https://www.masternodemonitor.app


Networks today:
 Beldex, BitCore, Cosanta, Dash, Divi, Energi, Firo, Flux, Neoxa, Oxen, PIVX, Raptoreum, SmartCash, SwiftCash, Syscoin, Terracoin.


Why I need you:
 Google Play requires 12 testers who stay opted in for 14 days before a new app can be published.


How to join (2 minutes):


1. Join the Google Group with the Google account you use on the Play Store: https://groups.google.com/g/mastermonitorapp-tests
2. Accept the test: https://play.google.com/apps/testing/crypto.masternode.monitor
3. Install the app from the Play Store and keep it for 14 days.


Prefer not to join a group? DM me your Google account email and I'll add you directly.


Feedback is welcome but not required. And a reminder: I will never ask for a seed phrase, a private key or money.


Thanks!

Hi, I am in the market for several years and I have some capital to invest. I am spesifically looking for 2017 coins these days, I feel like a few of them might make new highs (not ATH maybe but great peaks) in the 2029 bull run. But it seems like most of 2017 coins are either dead (XEM) or overpriced (Monero). I liked dash but I have a few concerns. Every bull high seems to be 3 times lower than the previous one which might mean there won’t even be a bull high this time. How do you guys know this coin will make another great high of maybe like 300 dollars in the next bull run (2029) and tbh why should I take this risk. Its 60 now and even it hits 300 thats only 6 times increase. I can do the exact same in Doge with a lot less risk considering that it is around 10 cents now and every bull run it goes to 50 cents after memecoin boom in each run. Also Doge coin is has billions of mcap and is a lot more trusted. So my question is basically why should I pick this coin and not another coin? My post kinda sounded like I am trying to pick on the coin but I want you guys to convince me to buy this coin. My investment can make a change in this coin!

Dash has one of the better bullish charts out there at the moment that no one is paying attention to currently. This is good thing as it creates a good opportunity for the sharp eyed folks out there looking for a quality token.

The chart shows DASH has formed a bullish falling wedge with an accumulation spanning an 8 year period. That's a lot of DASH market makers have been accumulating during this time. The falling wedge is a bullish pattern in which price is squeezed between two converging points utill a break out opccurs , The longer the falling wedge takes to form the more aggresive the final break out will be ,

If DASH remains above 34 I expect the first target up to be in the 190 to 200 area, I also suspect that Grayscaale may pick this up and open an ETF at some point. if you ask me DASH is a very good long term hold token with plenty of potential and rewards for the patient.

I wait patiently like the eagle to collect when the time is right.

What is a falling wedge ?

I was going to wait for the weekly close, but I really like how the chart looks right now. I think Dash will see prices above $100 before the year is out.

Evan Duffield wrote $DASH over a single weekend by his own account as a hobby.

What bothered him was specific. Bitcoin's transparency cuts both ways: pay for coffee once and the café can read your salary, your rent and your balance. Cash has no such memory. A banknote tells the next person nothing about the last one who held it, and that's the property $DASH was built to bring into crypto.

$DASH launched in January 2014 as XCoin, became Darkcoin two weeks later, and settled on its current name in 2015. $DASH is short for digital cash, and that was the point: money people would spend rather than sit on.

Making that work meant adding a second layer to the network. Masternodes sit above the miners and handle what blocks alone are too slow for, locking transactions so they settle instantly, mixing coins so they stop carrying a readable trail, and voting on how the treasury funds development.

Dash was the first chain to do any of this, and plenty of projects copied the idea afterwards.

Twelve years on it's still shipping. Dash Platform is live on mainnet, which gives the network usernames instead of addresses and somewhere for apps to store data. Core v24 arrived in July with Taproot support and the newer address format. Shielded transactions are coming to mobile, and a smart contract virtual machine is targeted for early next year.

Pasta's DashCon talk is not a "we built another X/Twitter clone." It is a live demonstration that Dash Platform can do something almost no other chain can: let a phone prove that a social network is telling the truth.

The app is called Yappr. It looks like X. Under the hood it is a client with no backend, talking straight to Dash Platform. Every name, every like count, every "this is the newest post," every "nothing is missing," and every "you are not allowed to see this" can come with a cryptographic receipt small enough to check on a phone.

That is the whole point of the presentation.

The lie you already live with

Open any social app. You see a name, a photo, some text, a number of likes, a "For You" ranking.

Who told you those numbers are real?

Twitter, X, Bluesky, Hive's website, a Farcaster indexer, they all answer that question with a database you are not allowed to see. Pasta's opening line is the whole talk in one sentence: every app you have ever used answered this question with the database you weren't allowed to see.

Imagine a town that posts a public bulletin board, then hands you a photocopy from the town hall. The hall could have omitted a flyer, inflated a vote tally, or buried a post. You can "verify" only by photocopying the entire archive yourself. Almost nobody does. That is how most "decentralized social" still works.

Hive and Steemit put posts on a chain. When you used the website, you were talking to their server. To actually prove they were not lying you would spin up a node with hundreds of gigs of RAM and sync the whole history. Lens and Farcaster need indexers. AT Protocol (Bluesky) is cool and open, and you still query something you hope is honest.

Writing is decentralized. Reading is still an act of faith.

Dash Platform's bet is that you should be able to ask "show me the 20 newest posts from people I follow" and get the answer plus a proof that the answer is complete and authentic, on the device in your pocket.

Four problems that look simple and are not

A single post is a bundle of hard questions:

1. Authenticity. Did this person actually write this? Signatures solve this. Almost every project has signatures. That is the easy part.
2. Lookup and ordering. Is this the newest? Is anything missing? Are they hiding a post they do not want you to see? On a normal database the server just tells you. To check, you would have to download everything.
3. Aggregation. How many likes? Did my like actually land? Centralized counters bug out (negative likes, vanished engagement). Downloading 50,000 like documents to add them yourself is not an app. It is a science project.
4. Ranking. What is actually trending? "Most liked today" is an opinion unless the ranking itself is a structure you can prove.

Social media is not a feed. It is a database product wearing a friendly face. The face was always cheap. The honest database was not.

The forest instead of the black box

Dash Platform stores application data in GroveDB, a grove, literally a tree of trees. Each tree is a Merkle structure. Trees nest inside trees. The whole forest hashes up to one root. That root is signed by a masternode quorum (BLS threshold signatures) and locked in by Dash's ChainLocks. Lie about a like count and you are not hacking a server. You are trying to get more than two-thirds of the Evolution nodes to collude and destroy the value of the network they are paid to run.

Think of it as a forest of signed ledgers. You do not carry the forest. You ask for one path through it and receive a tiny bundle of neighboring branches that hash to the same signed root everyone else sees.

Three structures do the social-media work:

Count trees (the pyramid of receipts).

Likes are not a flat list you scan. They drop into buckets that form a tree. The top of the tree is the total. Ask "how many likes?" and you get 312 plus a proof the size of a postcard, whether there are 312 likes or 3 million. The proof does not grow with the crowd. A bank statement that cannot silently change the total.

Range proofs (the missing-page detector).

"Give me posts between this time and that time." The proof includes the edges of the range. If someone tried to hide a post in the middle, the hashes would not match the signed root. You do not download Twitter. You download a notarized slice and the notary stamp.

Ranked indexes (the scoreboard that cannot be photoshopped).

When a like arrives, two things update: the count tree and a secondary ranking tree that re-keys by popularity. Walk right and you get "most liked." The walk itself is provable. Trending is not a machine-learning vibe from a cache. It is a tree you can audit.

Proofs Pasta showed were on the order of 1 to 13 KB. Page load in the demo ran dozens of queries. It still felt like a normal app, about a second even on a slow hotspot.

That combination is the claim, speed and proof at the same time, which the rest of the industry treated as a tradeoff.

What Yappr actually is

Yappr is a static website. No company server holds your posts. The browser talks to Dash Platform nodes. If Yappr vanished tomorrow, the data would still sit on the network and another frontend could query the same contracts.

Your identity is a key pair. Your human name comes from DPNS (Dash Platform Name Service), a username you can own, not a handle a company assigns. Posts, likes, follows, bookmarks, blocks, and store orders are documents in data contracts, signed by you.

In the live demo Pasta logged in with a QR scan against a DashPay-style wallet: identity, username, encryption keys for DMs and private feeds, authentication keys for likes. That is the "decentralized Twitter that does not feel like a homework assignment" piece the community has been waiting for.

What you can do today on the showcase (DevNet then, testnet moving toward mainnet with Platform 4.2 era work):

- 500-character posts, threads, quotes, reposts

- Likes and follows with proven counts

- Hashtags and an Explore page of trending topics (the #mood example had a proven like total)

- Mentions, bookmarks, lists

- Encrypted DMs

- Private feeds: content encrypted so only granted followers can read it; metadata can still be queried. Revoke a follower and a small "revocation tree" update re-keys the circle without rewriting every post.

- DashPay contact import: the people you already pay can be found and followed

- Tips via QR / payment URIs in Dash and other assets

- A full storefront contract: stores, items, variants, shipping zones, encrypted orders only buyer and seller can read, reviews after purchase

Fees in the demo were tiny YAP-token costs on the order of a cent or three per post or like, burned into the structure of the data rather than paid to a company. There is no ad server because there is no server.

Moderation works without a CEO. You publish block documents. Bloom filters keep "did I block this person?" cheap. You can subscribe to someone else's block list, borrowing judgment instead of inventing a Ministry of Truth. There can be a default list for the worst material that you can opt out of. The tradeoff is plain. Web2 has a king. Pure anarchy has no filters. This is user-sovereign filters you can prove.

Composability is the quiet superpower. Polls, blogs, stores, and social graphs can live in separate contracts and still be queried against the same proven state. A tip address is just an address. No platform cut unless you choose one.

Forkability is the insurance policy. Change the contract ID and you have a new app on the same identities and the same proofs. Steemit-to-Hive required a messy social and technical divorce. Here the data does not belong to the website. The website is a lens.

Why a layperson should care

You already use databases you cannot audit. Your bank app, your airline miles, your social score, your "recommended for you." Crypto promised to fix money. Dash Platform is trying to fix the other half, the records of who said what, who paid whom, who is allowed to see the private post.

For a creator, the old DashPay pain was real, the friend-request rails and "be online to approve." Yappr's direction is the opposite of that bottleneck, with identity you control, a username people can find, a tip jar that is just an address, contacts you already have, and content no host can delete because they never hosted it.

Here is the allegory that sticks. Other chains gave you a public square with a private photocopier in the back room. Dash is trying to hand every reader a notarized page and a stamp that the rest of the book matches.

It will not feel magical if the UX is ugly or names are hard. Pasta's demo is arguing the hard part (the database that can be proven) is now real enough to put a familiar interface on top. The remaining work is wallets, names, fees people do not notice, and enough apps that "query the grove" becomes as boring as "load the page."

Yappr is one app. The presentation is about the platform underneath it. If GroveDB proofs stay small and queries stay rich, the next "simple" product (a marketplace, a membership feed, a local bulletin, a tip-enabled blog) does not need a company to hold the books.

That is the story Pasta was telling. Not another timeline, but a timeline you can check.

Watch the full talk here:

https://www.youtube.com/watch?v=G6LPqLTSJI8

Hey r/dashpay — first time posting here, so a quick intro:

I built Backpow (https://backpow.com), a free data platform and Proof-of-Work oracle that tracks the physical mining economics behind PoW coins in real time.

Most people only look at the spot price ticker. But Proof of Work has a physical anchor that exchange charts and market sentiment cannot fake: the thermodynamic Cost of Production (CoP). The real-world cost to produce a coin is driven by the energy pulled from the wall, the network difficulty, and the actual hardware miners keep plugged in.

We just added full coverage for Dash: https://backpow.com/Dash

For Dash, we track:

• Continuous Cost of Production vs spot price, complete with 30-day history and time spent underwater
• A ranked hardware board — covering 27 X11 ASICs sorted by production cost per coin and daily revenue
• An efficiency frontier map (power vs hashrate) to spot real generational hardware leaps
• Solo mining Poisson odds — estimated block discovery times per machine

Why this matters:

• For active miners: It gives you a cold, hard benchmark on whether your electricity tariff keeps your rigs profitable or if you are running an expensive space heater.
• For long-term holders & accumulators: Understanding when spot trades below or near network production cost shows whether miners are subsidizing the security of the network out of pocket, which historically marks key economic equilibrium zones.

I posted a visual thread with the 30-day CoP curves, hardware rankings, and efficiency maps over on X:
https://x.com/BackpowCom/status/2099226375869595719

Would love feedback from active Dash miners — if any power profiles or hashrates for your specific X11 ASICs look different from your real-world setups, please let me know so we can refine the data.

Thanks guys <3

Noticed something odd while looking at social data for Dash today. Mention volume doubled compared to its recent average, 180 mentions versus a baseline of around 90, which is a 2x spike. Normally when you see a jump like that there's some obvious trigger: a partnership announcement, an exchange listing, a exploit, something. This time there's nothing like that showing up.

The sentiment behind the chatter is basically neutral, not a wave of bullish hype or bearish panic, just more people talking about Dash than usual. Price has stayed flat through all of this too, so whatever's driving the mention count isn't translating into any real market reaction yet. That combo of a real, measurable volume spike with no clear catalyst is honestly one of the more interesting patterns to see in this kind of data because it means either something is brewing under the radar or it's just noise/bot chatter that happened to cluster.

Worth keeping an eye on whether this resolves into an actual narrative in the next few days or just fades back to baseline. Anyone seeing specific discussions or news around Dash right now that could explain the sudden interest?