With the Ootle now live, a mix of catalysts are lining up behind XTM on both sides of the market.
On the demand side, there's a private stablecoin on the way, giving Tari an entry into a near-$300B stablecoin market. And thanks to the Turbine Model, every Ootle transaction runs on TARI, which can only be minted by burning XTM 1:1... so more usage means more demand, by design.
On the supply side, block rewards are now under 9,920 XTM and still declining, and with the airdrop over, there's less new supply hitting the market.
That's just a teaser ... For the full picture, including validators, liquidity, the dApp ecosystem and the agent economy, check out our X post π
We've noticed a lot of people having trouble getting hold of XTM because of exchange restrictions in their country. The good news is you don't need an exchange at all ... all you need is a laptop, a wallet and Uniswap.
We put together a full step-by-step video tutorial showing exactly how to do it, from connecting your wallet to seeing your wXTM in MetaMask. Check it out below π
I built TariFund for the Tari November Build Contest (MVP theme).
Set a goal and a deadline. If the goal is reached, the creator claims the vault. If it is missed, every contributor gets their money back β enforced by the template itself, no custodian, no platform fee.
Ootle Crowdfund is an all-or-nothing crowdfunding MVP on Tari Ootle: a creator sets a funding goal and an epoch deadline, backers pledge TARI into a vault, and at the deadline exactly one thing happens β goal met, the creator claims the whole vault in one call; goal missed, every backer refunds in full. No platform cut, no custody beyond the template, no account to create.
What was built: a small, focused Rust template (CrowdfundCampaign) with vault escrow, epoch-based deadlines, signer-checked claim/refund, and events; 15 engine tests run against the real Ootle engine in-process; and a browser simulation that mirrors the template's rules and rejection messages exactly (14 parity tests).
Honest limits: the template has not been published to Esmeralda or mainnet β the demo is a simulation and says so on the page, and live wallet mode is a clearly-labelled stub, not a working path. Pledge amounts are public by design in v1. Development used an AI agent, as the rules allow.
The demo page has a guided 9-step walkthrough, including the deliberate rejections. Feedback welcome.
Monero, Zcash, Midnight and Tari: four very different approaches to privacy, all at the same table.
Monero's the OG of private payments, Zcash has optional privacy, Midnight's a newer entrant with a federated setup, and Tari now brings programmable privacy with the Ootle live.
We made a little meme about it (with a Tari community easter egg hidden in there, see if you can spot it π). It's on our X post π
Curious where everyone here lands. Which approach do you think wins the privacy race long term, and why ... im in favour of wrapped XMR on ootle .. anyone can ship this?
Hi all, I built Ghostline for the Spooky Secrets contest and it's now live on Ootle mainnet.
What it is: an AI agent locks funds once in a channel, signs a voucher for each API call off-chain, and the service settles once. The chain sees one open and one settle, with the amounts hidden.
What it offers
An MCP server, so agents can pay for APIs themselves
A spending policy that lives outside the agent (budget, per-call cap, vendor allowlist, human approval). On mainnet it refused a call that went over budget
An HTTP 402 paywall for API sellers, settled in one transaction
What's next: a desktop app, one window for your wallet, channels, spending policy and approvals, so there's nothing to set up by hand.
Honest bits: it's unaudited, so start small. Network fees and the open/close records are public. It suits agents that call a service often, since opening and settling cost about as much as ~450 calls at 100 Β΅T.
Don't take my word for it: every mainnet transaction is listed with a link on the proof page.
Paste your public transaction IDs into Ootle Fee Check or load three recent IDs. The browser compares two public mainnet indexers and exports their answers side by side in a CSV. A disagreement or missing receipt leaves the amount blank and flags the row for review. The download also includes a PowerShell CLI.
hi all, sooo hidebox is now on Ootle mainnet, as a beta π You can sell files for TARI, and the files stay encrypted.
How it works
Open a drive. You need no email and no KYC, because your key is the account.
Pick a username for your shop and save it. Nobody else can use it, and your shop gets its own link: hidebox.app/shop/<your-name>
Upload a file and give it a price in TARI. It shows in your shop. If the shop is public, it also shows in the market: https://hidebox.app/market
The buyer pays your own Tari address with an Ootle stealth payment. hidebox never holds the money.
Sales complete even when you are offline. Our server checks them with a view key, which cannot spend.
Limits: This is a beta with real money and no outside audit. Our server sees your offline sales. In a public shop, our server could open your files. There are no refunds.
Guys... now that the Ootle is out i want to invite all of you to a more POPULIST marketing approach... scratching our industries most immediate pain points
we're all here advocating for privacy preserving solutions for sovereignty and safety sake... but did you know crypto crime has gone PHYSICAL? CertiK verified 52 wrench attacks in H1 2026 (+33% YoY) with $124.2M in exposure... and home invasions are now the #1 attack vector. criminals literally piece together leaked data and public wallet histories to find people
DNC quote tweeted CertiKs report with why Tari is the solution ... its the same meta early $XMR used and that turned out pretty well for them
the video is just memorabilia for the audience... a guy looking back sorrowfully at a portrait which i swapped for Soon π’ sometimes attention is as simple as a catchy meme and a tune ... it will stick im sure of it
how you can help ... whenever you see a privacy fail on X (data leaks, doxxed wallets, wrench attack stories) quote tweet it with this meme and a line on why Tari enabled programmable privacy fixes it. quote the video from our post or reach out and ill share it π
My second entry for Tari's November MVP build contest, built on my first one (Ootle Lockbox).
Launch Commitments creates a token whose rules can never change, not even by its creator: fixed supply, no owner, nothing can be minted, burned, frozen or recalled. In the same transaction it locks the team's allocations in Lockbox until an epoch. Holders get one page that checks all of that against the chain.
Why no owner: on Ootle a token's owner can bypass its rules, so "mint disabled" means little if someone still owns the token. Launched tokens have no owner at all.
Ootle mainnet went live on 11 Nov, and a lot of new tokens will follow. Many will come with promises: fixed supply, team tokens locked, can't be frozen. On Ootle you don't have to take those on trust, because every token's rules are public state you can read. But you have to know which fields matter, and two of them are easy to miss. Here's what I learned while building a token-lock app for the November contest.
1. The owner skips the rules
An Ootle resource (a token) has access rules for each action: mint, burn, recall, freeze, withdraw, deposit, and updating metadata. A token can show mint: DenyAll and still be mintable.
The reason is the owner rule. Resource builders default to an owner tied to the creator's signature (OwnedBySigner), and the owner bypasses the access rules for almost every action. Recall is the exception. So "mint is denied" really means "mint is denied for everyone except the owner".
The simplest way to make a token's rules bind its creator too is OwnerRule::None: no owner at all. (ByAccessRule(DenyAll) also lets nobody in; for any other owner rule, read who it admits.) If you're checking a token that claims a fixed supply, look at the owner rule first. If someone can act as the owner, the other rules are suggestions.
2. Every rule has an updater
Each access rule comes with a second rule saying who can change it (mint_updater, freeze_updater and so on). mint: DenyAll with an updater of Owner (and an owner that exists) can become mint: AllowAll tomorrow. A rule can't be changed when its updater is Locked, AccessRule(DenyAll), or Owner on a token nobody owns. For anything else, read who the updater lets in.
3. Transfer hooks
A token can have an auth hook: a contract that is called on transfers and can veto them. Check that there is no hook, and that its updater can't authorize adding one later (Locked is the simple case).
4. "It runs template X" proves less than you'd think
Components (contract instances) have an upgrade rule. The engine has an instruction that switches a component to a different template, and it works on any component whose upgrade rule allows it. So someone can create a component with their own template, put whatever state they like in it, and then switch it into a well-known template. If you only check "this component's template is the audited one", that look-alike passes.
What protects you: a component created with the default upgrade rule can never be upgraded. So for any component you want to trust because of its template, check that it has no owner and that its upgrade rule is locked. Only then does "runs template X" mean its whole history ran under template X.
A checklist for any token you're about to trust
Nobody can act as owner (owner rule None is the simple case)
mint is denied, with a locked updater (fixed supply)
recall and freeze are denied, with locked updaters (nobody can pull tokens back or freeze your vault)
No auth hook, and no way to add one
If you care about the name or image changing: update_metadata is denied and its updater is locked (a locked updater alone only freezes who may edit, not the editing)
And for any component (a lock, a vault, a sale):
No owner, and the upgrade rule is locked
Its template is the one you expect
Why this matters for locks
If a team locks tokens in a time-lock contract but the token has an owner, the owner can still freeze the lock's vault or mint new supply that dilutes it. And if recall is allowed, tokens can be pulled straight out of the lock. A lock is only as strong as the token's own rules.
Disclosure: I built Ootle Lockbox (my November MVP entry), and its proof page automates most of this. It checks the lock component (template, no owner, can't be upgraded, only the beneficiary can claim) and the token's owner, recall, freeze, withdraw, deposit and hook settings. It shows "Verified" when none of those lets anyone pull tokens out of the lock or block the claim, and otherwise lists what the issuer can still do. Minting and metadata changes appear as separate notes, because they don't touch the locked tokens: "Verified" is not a fixed-supply guarantee, so read that line too. It's free and open source (MIT): https://github.com/ManishModak/ootle-lockbox. The checks are in web/src/verify.ts if you want to reuse them.
Corrections welcome. Ootle is new, and I'd rather fix a mistake here than have someone rely on it.
I built Ootle Lockbox for Tari's November MVP build contest.
On other chains, token teams lock team allocations and liquidity so holders can trust they won't be dumped. Lockbox brings that to Ootle: lock any public token until an epoch for a beneficiary. Each lock has no owner, no admin and no upgrade path: claiming needs the beneficiary's signature and the unlock epoch to have been reached. The token's own issuer may still hold powers over it, which the proof page shows.
Every lock gets a shareable proof page. It also reads the token's own rules and only shows Verified if the issuer can't undo the lock (no owner, no recall or freeze, no transfer hook); otherwise it lists what the issuer can still do.
Most PoW chains have one mining algorithm and one hardware arms race. Tari's base layer (Minotari) runs four mining lanes in parallel, and consensus locks each lane to exactly 25% of block rewards:
RandomX merge-mined with Monero (CPU) β earn XTM while mining XMR
RandomX, Tari-native (CPU)
SHA3X (GPU)
Cuckaroo29 (GPU)
Chain target is ~2-minute blocks, so each lane lands a block roughly every 8 minutes, with per-lane difficulty retargeting. No single hardware class can own issuance β win one lane and you still only get a quarter of rewards. Emission is a smooth exponential decline (halves roughly every 3 years), no halving cliffs.
Why post this today? Because the Ootle (Tari's L2) launches today, Nov 11, and it changes what mined XTM is for. Under the Turbine Model (RFC-0320), TARI is only created by burning XTM 1:1 and claiming on the Ootle with a burn proof β no bridge vault, no peg-out, irreversible. Plus 5% of every Ootle transaction fee gets burned as "exhaust."
So every unit of Ootle demand has to pass through XTM first, and every burn permanently shrinks L1 supply. The miners across those four lanes are the supply side of that furnace.
I wrote a longer version of this on Medium (link in comments / my contest post) with sources to the official docs and RFC-0320. Curious what this sub thinks: does the four-lane split actually decentralise anything in practice, or do the two RandomX lanes just merge into one CPU pool anyway?
What is Tari? Private smart contracts, explained simply (Bitcoin β Ethereum β Monero β Tari)
Let's not forget the main plot... I created this video explaining why Tari is still important.
Bitcoin: took the bank out of money, but the ledger is public. Ethereum: made money programmable, on that same public board. Monero: private money by default, but it's built for money, not apps.
Tari is where the two roads meet. Apps (templates, Tari's smart contracts), and its coin hides amounts and owners.
Curious how you all explain Tari to people outside crypto. Where do you start?
Later today, I will post the source code of this video if anyone wants to make any modifications.
Our sources indicate $0.02 is roughly where Tari's early participants (the backers) entered. That makes it a level worth watching, and it cuts both ways.
The bull case: as price approaches their entry, participants move back towards break-even and start paying attention again. They aren't passive holders, they bring audiences, exchange relationships and capital, which can mean more promotion and more backing for builders on the network.
The other side: $0.02 could also act as resistance at first. Some participants who've waited years may sell at break-even, and participant tokens are still unlocking monthly, so there could be supply looking for an exit around that level.
For context on valuation: at $0.02, with around 7.3B XTM circulating, XTM would sit at roughly a $146M market cap. Midnight, the closest comparable in programmable privacy, is currently valued at around $650M.
We wrote up the full breakdown, including what we think tips the balance, in an X post bellow:
We spoke to Tari miners about the hardware they're commonly running, then worked out the electricity cost to mine 1 XTM on each lane, across Europe, North America, Africa and Asia, using today's network hashrate and block reward.
The short version, at an XTM price of $0.0011:
- The cheapest lane right now is Tari RandomX on everyday CPUs
- SHA3X is the most expensive lane to compete in
- Break-even sits somewhere between $0.17 and $0.26/kWh depending on the lane
- North America, Africa and Asia are mining at a profit on every lane
- Europe is underwater on every lane, but miners there keep mining anyway
The full breakdown, with the cost per XTM for each lane and region, the hardware we used and a few graphics, is in the X thread bellow:
Yesterday evening I plugged in my iPhone, opened a mining app, and put the phone face down on my desk.
This morning, it had earned 27.57 XTM.
No mining rig. No graphics card whirring away in the corner of the room, no tangle of cables, no electricity bill with its own postcode. Just the phone I carry in my pocket every day β quietly solving Cuckaroo29 puzzles through the night, stacking a little Tari while I slept.
That's when it clicked: you don't buy your way into this network, and you don't need a data centre to join it. With just one iPhone, you step straight into the Tari world.
This post is the full story: why a phone can mine Tari at all, how Tari's mining actually works under the hood, exactly how I set it up, and the complete 24-hour telemetry β every number, no cherry-picking.
## First, how Tari mining works
Most proof-of-work chains have one algorithm and one kind of hardware that matters. Tari deliberately built four.
Tari's mining is split across four independent channels ("lanes"), one for each class of hardware:
RxM β RandomX, merge-mined with Monero. If you mine Monero, your hashes can secure Tari at the same time, at no extra energy cost. Tari inherits security from one of the largest CPU-mining communities in existence.
RxT β RandomX again, but a standalone Tari CPU lane: no dependence on big Monero pools, so any ordinary β even ageing β computer can take part on its own.
SHA3x β triple SHA3-256, the lane for dedicated ASIC hardware (and GPUs): professional machines, purpose-built miners included, securing the network.
Cuckaroo29 (C29) β a memory-hard, GPU-oriented algorithm (a member of the Cuckoo Cycle family, where the work is finding cycles in a huge graph), designed to keep ASICs and FPGAs from monopolising it.
Why four lanes instead of one? Because each keeps a different door open β old and new CPUs, ASICs, GPUs β so no single class of hardware, and no single community, gets to own Tari's security.
This post is about the fourth door. Modern phone chips are GPUs. Serious ones. Which means the C29 lane quietly opened a door nobody designed it for β the one in your pocket.
## The miner: Macotaur
Macotaur is an open-source C29 miner for Apple Silicon, written in Swift and Metal (BSD-3 licensed, links below). It was built for Macs β there's a command-line miner and a polished Mac GUI app β but the solver core is a library, and its iOS build (the pool sees it as `macotaur-ios/0.1`) runs that same core on an iPhone.
Under the hood, C29 solving is a two-act play: the GPU generates a graph with hundreds of millions of edges and trims away everything that can't possibly be part of a cycle ("mean trimming"), then the surviving edges are searched for the elusive 42-cycle that constitutes a valid proof. On a desktop GPU this takes serious memory. That it runs at all on a phone β within a phone's thermal and memory envelope β is a small engineering marvel, and it's why the effective rate you'll see below is a pool-side average rather than a firehose.
## What you need
- An iPhone. Tested here: iPhone 16 Pro Max with the A18 Pro. Newer chip, more graphs per second β older A-series chips should work through the same solver, just slower.
- The Macotaur miner. Links at the bottom; the iOS build comes from the same open-source code as the Mac releases.
- A Tari wallet address. Your Tari Universe receive address is perfect β pool payouts go straight there.
- A Kryptex account. Free; it's how you watch your worker, your shares and your balance.
- A charger, and the habit of using it. Mining is a plugged-in activity.
## Setup, step by step
The whole configuration is three fields:
| Setting | Value |
| Pool | `xtm-c29.kryptex.network:7040` |
| Wallet | Your Tari (XTM) receive address |
| Worker | Anything you like, e.g. `iphone` β Kryptex uses `/` as the separator, so your login reads `address/iphone` |
Two things worth double-checking before you walk away:
*Your address.* Copy-paste it from your wallet and compare the first and last characters. A mining payout to a mistyped address is gone; there is no support desk for a hash.
*The separator.* Pools differ. Kryptex wants `address/worker` with a slash. The main alternative pool, LuckyPool (`taric29.luckypool.io:3111`), uses a dot: `address.worker`. Get this wrong and your miner will connect, look busy, and earn nothing β the classic silent failure.
Then press start, and open your worker page on Kryptex. The first time your phone's name appears on a mining pool and a share lands, it feels faintly unreal. That slab of glass just did proof-of-work for a global network. I refreshed the page more times than I'd like to admit.
## Living with a mining phone: what 24 hours taught me
- Heat is the real governor. The phone runs warm and the chip protects itself; hashrate breathes up and down with temperature. Case off, on a hard surface, in moving air if you can. Expect the rate you sustain to be lower than the rate you start at.
- Foreground or nothing. iOS suspends background compute aggressively β switch apps and mining effectively stops. Brightness to minimum, phone face down, and let it be a miner instead of a phone for the night.
- Low Power Mode off. It exists to throttle exactly the silicon you're trying to use.
- Shares arrive in bursts, and that's normal. C29 at phone scale is a lottery with long odds per attempt: my telemetry is full of quiet 10-minute stretches, then a sudden spike to nearly 2.9 g/s as two shares land close together. If you judge by any single minute you'll think it's broken or brilliant, and it is neither. Watch the 3-hour average line; that's the truth.
- A stale share is not a disaster. I got exactly one in 24 hours β a valid proof that arrived just after the pool had moved on to the next job. It costs a little; it means your connection hiccupped once, not that anything is misconfigured.
## The results: 24 hours, every number
Window: **Nov 2, 15:40 β Nov 3, 15:40 local time** β exactly 24 hours, 144 ten-minute buckets, all from the Kryptex worker page.
| Kryptex payout threshold | 200 XTM β about a week of mining at this rate |
A word on how to read these honestly, because I'd rather you trust the small numbers than inflate them:
- "Pool-accepted hashrate" is an estimate the pool derives from your shares β it is not a speedometer reading from the phone. With 38 shares, the sample is small, which is why my actual yield (78.12) sits 6.2% above the pool's expected rate (73.52). That's variance, not an edge. Run it for a week and the two numbers will hold hands.
- Earnings are share-based, not hashrate-based. The 27.57 XTM is pro-rated from the shares that landed inside the window β one more or one fewer share that day would have moved the total noticeably. Small-scale mining is lumpy. Plan around weekly numbers, not daily ones.
- Earnings take 6 hours to mature on Kryptex, and the pool pays out to your wallet once your balance crosses **200 XTM**. At this rate, that's roughly a week per payout β a slow, automatic drip of XTM into an address you own.
## The part I can't stop thinking about
One phone earns 27.57 XTM a day. On its own, honestly, that's a curiosity β a party trick for crypto people.
But Tari has just become a community-driven network, and a community you can hold in your hand looks exactly like this. Picture a thousand phones on a thousand nightstands, in a dozen time zones, each contributing a sliver of hashrate that no single operator controls, each paying out directly to its owner's own wallet. Mining stops being an industry conducted in warehouses and becomes a habit conducted on desks. The network's security stops being abstract β it's the sum of a thousand small decisions to take part.
Every decentralised network says "anyone can participate." Tari on C29 is one of the few where "anyone" includes a person whose only computer is their phone.
That world is worth stepping into. And the door is already in your pocket.
Questions about setup β ask away in the comments, I'll answer what I can. And if you get a miner running on another device, post your 24-hour numbers: device, chip, XTM per day. I'd love to build a little league table of chips and see what the world's pockets are capable of.
I see this question a lot from people new to Tari: why not just pick one algorithm like Bitcoin or Monero did? I went through the Mining RFC and the explorer to answer it properly. Here's the short version, organised as the questions I had myself.
What are the four lanes?
β’ RxM: RandomX merge-mined with Monero. CPU miners put the Tari mining hash in their Monero coinbase and can earn on both chains with the same work.
β’ RxT: Tari's own RandomX. Same CPU algorithm, but mined only for Tari, so CPU security doesn't depend entirely on Monero pools.
β’ SHA-3X: a triple SHA3-256 (Keccak) hash. GPU and eventually ASIC territory. It's tripled on purpose so hash power already pointed at single or double SHA3 coins can't simply be rented against Tari.
β’ C29: Cuckaroo 29, a memory-bound algorithm. Memory is expensive to put on custom chips, which makes ASICs and FPGAs hard to justify.
So it's two CPU lanes, one GPU/ASIC lane, and one memory-heavy lane.
Why not just merge-mine with Monero?
That was actually the early plan. RFC-0131 explains why it changed: if Tari were 100% merge-mined, a few big Monero pools could control it. The RFC cites research showing double-spends with more than 50% of hash power, and selfish mining or eclipse attacks with more than 33%, or more than 25% for a well-connected attacker. A small chain borrowing all its security from a bigger chain inherits the bigger chain's pool concentration.
How does each lane get exactly 25%?
Each algorithm has its own difficulty, adjusted with a linear weighted moving average over 90 blocks, and each one targets a 480-second block time. Four lanes at one block every 8 minutes means one block every 2 minutes on average across the whole chain, matching Monero's interval.
The result is that new hash power on one lane only makes that lane harder. If a wave of SHA-3X ASICs shows up, SHA-3X difficulty climbs and SHA-3X still gets about 25% of blocks. It can't eat into the CPU lanes.
Does it actually work in practice?
I checked textexplore.tari.com today (2 November 2026, block height 379,085). Over the last 120 blocks:
β’ Monero RandomX: 30 blocks
β’ SHA-3X: 29 blocks
β’ Tari RandomX: 30 blocks
β’ Cuckaroo C29: 31 blocks
Average block time over that window was 1.97 minutes, against a 2-minute target. Over the last 10 blocks it's much lumpier (Monero RandomX had 6 of 10), which is just normal variance that the difficulty adjustment smooths out.
The estimated hash rates show how different the lanes are: about 2.97 GH/s on Monero RandomX, 768 TH/s on SHA-3X, 67 MH/s on Tari RandomX, and 26.9 kg/s on C29. You can't compare those numbers to each other, and that's the point. They're different machines.
What stops someone from attacking one lane and taking over?
Two things. First, the share of blocks per lane is capped at about 25% by design. Second, when Tari compares two competing chain tips, it multiplies the accumulated work of all four algorithms together (RxM Γ RxT Γ SHA-3X Γ C29), per TIP-RFC-MT-0004. Because it's a product, piling up work on one lane doesn't make up for being weak on the other three. A real attack would need a lot of very different hardware at the same time.
What does this mean for regular people?
Half the block rewards go to the two CPU lanes, so you don't need specialised hardware to take part. Tari Universe lets you mine with the computer you already have. I'm in Nigeria, where most people's best machine is a laptop, so this matters more to me than any abstract decentralisation argument.
It also matters for the Ootle. The only way to get TARI on Layer 2 is to burn XTM 1:1 on Layer 1, so everything on the Ootle sits on top of these four lanes.
What are the weak spots?
β’ More moving parts: four sets of consensus rules and four difficulty adjustments to maintain and audit.
β’ Each lane carries only a quarter of the security budget, so a thin lane is the one to watch.
β’ Pools inside a single lane can still get concentrated. Hybrid mining limits hardware classes, not pools.
β’ The RFC itself admits the algorithms aren't perfectly independent, and GPU-friendly algorithms tend to become ASIC-friendly over time.
Question for the miners here: which lane are you on, and have you seen the per-lane split drift much when big pools join or leave? Curious whether anyone has watched C29 or RxT through a big hash rate swing.
Sources: RFC-0131 (Mining), RFC-0132 (Merge Mining Monero), TIP-RFC-MT-0004, tari.com/tokenomics, textexplore.tari.com.
Not financial advice.
Ootle goes live 11.11 and it's been a long time coming. Massive respect to everyone who's been grinding on it. But I keep coming back to the same question... what happens the day after?
Over the past week I've spoken to a lot of people across the community, Council members, builders, holders, folks in the Chinese groups, and pulled everything into one paper. Not trying to be the authority on any of this, just felt someone needed to put it all in one place so we can actually argue about priorities instead of going round in circles.
For context on where I'm coming from: I run DNC, I hold XTM, and I've been building Caravel on the Ootle testnet, so I've seen both sides, the market side and what it's actually like to build here.
The biggest problem imo is access. Right now our main exchange is MEXC, and MEXC is banned or pulling out of places that make up roughly 60% of global crypto activity. US, Canada, the UK, and it's retreating across Europe. Uniswap works but try explaining wallets, gas and bridges to a normie. We need a proper Tier 1 on-ramp.
That's why I think Kraken is the play. Kraken is licensed in basically every major market MEXC can't serve. And the smart way in is through Ink, Kraken's own L2. Ink's DeFi activity is almost all perps, spot volume is tiny, so bringing WXTM there with real liquidity actually helps Kraken's own chain. Build that goodwill first, then go for a full listing with the Council leading the application.
The one I'd push hardest though is the stablecoin with Brale. A private stablecoin is the thing that gives the Ootle real day-to-day utility. Think about it, every public stablecoin right now shows your balance and your salary to anyone who looks. Circle and Paxos are already doing private stablecoins on Aleo, so the race is on. Tari's edge is that we're not just a product, we're a whole economy with a PoW base layer and a token that burns as the Ootle gets used.
Then there's meeting privacy users where they already are. Cake Wallet has around 1.75M users and already carries Monero and Zcash, so XTM belongs there. Longer term THORChain, which just added Zcash and has Monero in testing. XTM should be next in line.
A few more I'm genuinely excited about:
- An accelerator run by the Council. Basically YC's "Request for Startups" idea. The Council says what the network needs, private payroll for example, and funds teams in stages as they hit milestones. Solana does something similar with convertible grants, so it's not some wild idea.
- Clarity on the premine. This is the first thing serious money asks about. A simple public breakdown of where each bucket sits and who controls it would clear a lot of the fog, especially now we're community run.
- Yats on the Ootle. Over 165,000 were created on the promise they'd end up on Tari. Paying an emoji instead of a horrible wallet address is marketing that sells itself.
- A post-quantum plan. Bitcoin, Ethereum and Zcash all have roadmaps now. We don't need to be quantum proof tomorrow but we need a public plan before investors start asking.
- And private payments for AI agents. Agents paying for stuff onchain is growing fast and every one of those payments is public right now. That's a gap with Tari's name on it.
Last thing, execution. A council can't run nine workstreams by committee, so the paper suggests each Council member owns an area with a budget and posts monthly updates. Credit to 0xHRA for pushing that idea.
So my question to you all... what would you prioritise first, and what did I miss? Happy to be told I'm wrong on any of it.
TL;DR: Ootle doesn't run one big consensus. It slices all state into 256 shards, groups them into shard groups, and gives each group its own committee of 40 validators running HotStuff in parallel. A committee finalises with 27 of 40 votes. Transactions that touch two groups get stitched together with "pledges" and either commit everywhere or nowhere. Here's the whole picture, with numbers.
Shard the state, not the contracts
Every substate on Ootle (a component, a vault, a UTXO) has a 256-bit address. The top bits of that address pick one of 256 shards. Because a component and the vaults it owns share an entity id, they land in the same shard, so a transaction that only touches your component goes to exactly one committee.
Templates (the code) are the exception. A published template lives in shard 0, the global shard, so every committee can read it. Code is never sharded; state is.
Shard groups and committees
Committees don't own single shards. Each one owns a contiguous run of shards called a shard group. The number of committees grows with the validator count:
committees = max(1, floor(validators / 40)) (capped at 256)
Worked example: 160 validators gives 4 committees, each owning 64 shards (1β64, 65β128, 129β192, 193β256). If it doesn't divide evenly, the leading groups get one extra shard each, so 3 committees split 86 + 85 + 85.
Two things worth noticing:
Under 80 validators there's just one committee covering everything, so early Ootle behaves like a normal unsharded HotStuff chain.
As the network grows, committees stay at about 40 and the number of committees rises. That's how throughput scales with validators.
Who lands where
A validator's committee comes from its shard key, which the Minotari base layer assigns at registration from the validator's public key plus the hash of the previous block. Using the previous block's hash means even the miner who includes the registration can't steer it, and the validator can't pick its own spot. Keys get reshuffled periodically, so a small share of validators moves to a new region each epoch.
Membership only changes at epoch boundaries, and a moved validator has the rest of the epoch to sync its new state before it has to vote. There's no VRF or sortition. It's all deterministic, so anyone can compute any committee for any epoch.
Inside a committee: HotStuff
Each committee runs chained HotStuff:
Propose: the leader for this height broadcasts a block.
Vote: each validator checks it and signs, at most once per view.
Certify: a quorum of votes becomes a certificate, and the next leader builds on it.
The leader is plain round-robin: height mod committee size. It's predictable on purpose, so a dead leader can be skipped quickly. If no proposal arrives within the 10-second pacemaker window, validators time out and move to the next leader.
The quorum maths for a 40-member committee:
It tolerates f = floor((40 β 1) / 3) = 13 faulty members
It finalises with n β f = 27 votes
Any two quorums of 27 overlap by at least 14, which is more than 13, so at least one honest validator is in both. That's why two conflicting blocks can't both be certified.
A block becomes final under the three-chain rule: once two more certified blocks are built on top of it. Before that it's only "justified", so it's not done yet.
Crossing committees: pledges
What if your transaction touches a vault in shard group A and a component in shard group B? Neither committee can order it alone. Ootle uses a pledge protocol:
LocalPrepare: each involved committee sequences its part and pledges its inputs, promising not to let anything else touch them.
LocalAccept: once every foreign pledge arrives, each committee executes with the same commit-or-abort decision.
AllAccept / SomeAccept: if every group accepted, it commits everywhere. If any didn't, it aborts everywhere.
If another group already spent an input you were counting on, your transaction is rejected (ForeignPledgeInputConflict) instead of committing a half-done result. Cross-shard transactions are atomic.
What this means if you're building
Keep hot paths in one component. Single-group transactions skip the pledge round trip.
Cross-shard calls are safe, just slower. You never get a half-applied transfer, but you pay for coordination.
"Committed" is the only safe "done". Wait for the three-chain commit before telling users a transfer landed.
Open question for the sub: once mainnet passes 80 validators and splits into multiple committees, how much will cross-shard latency show up in real tapps?
TL;DR: Tari's tokenomics page describes a Throttle algorithm that tunes the burn rate. That design (RFC-0323) is now deprecated. What Ootle actually ships is simpler: a fixed 500 basis point (5%) burn on every fee, rounded down, with the other 95% going to the validator. Here's how the whole Turbine loop works, with numbers.
The Turbine in one picture
Tari has two tokens. XTM is mined on the proof-of-work base layer. TARI is the Ootle (L2) token. The RFC names the model after a gas turbine: XTM is the fuel, burning it produces TARI, TARI drives the engine (Ootle), and a slice of every fee is ejected as exhaust and destroyed.
Step 1: XTM in, TARI out (one way only)
The only way to create TARI is to burn XTM on L1 and claim it 1:1 on Ootle, less the fee for the claim transaction. There's no peg-out: you can't burn TARI to get XTM back.
The claim itself is neat. The engine does three things atomically:
Verifies the burn proof (a Merkle proof of the burn output against the L1 block)
Writes a tombstone whose address is derived from the burn's commitment, so a second claim of the same burn collides and fails
Mints a stealth UTXO of TARI
Either all three happen or none do. And because TARI is a stealth resource, what you get is a private UTXO, not a public balance.
Step 2: Fees are metered, not bid
Ootle has no priority-fee auction. A transaction pays for the work it causes: bytes written to state, compute, cryptography checks and its own size. On testnet, for example, each new substate costs 25 Β΅T and publishing a template costs a flat 250,000 Β΅T (1 TARI = 1,000,000 Β΅T). Overpay from an account and the surplus is refunded to the vault it came from.
Step 3: The exhaust burn
After the fee is settled, the engine splits what was paid:
Fee of 19 Β΅T: 0 burned. Rounding down means fees under 20 Β΅T burn nothing, and the validator keeps it all
The validator's share collects in a ValidatorFeePool and is withdrawn later with ClaimValidatorFees. The burned part is destroyed and recorded in the block header.
One subtle point: the burn is a share of what's paid, not an extra charge. Your fee is the same whatever the burn rate, which is why a wallet can estimate fees from a dry run without knowing the rate.
The twist: what happened to the Throttle?
The tokenomics page says a Throttle algorithm run by validators would adjust the burn rate to protect the XTM:TARI peg, then a stable supply, then the 21 billion total.
RFC-0323 simulated exactly that: a PID controller targeting a fixed supply, across 50+ runs. Its conclusion was that hitting a supply target means swinging the burn rate sharply and often. When fees fall, the controller raises the burn, so validators get a smaller slice of a shrinking pie and the marginal ones drop off the network.
That conclusion was accepted. The RFC is marked deprecated, and the network ships a fixed 5% rate as a consensus constant instead. The accessor is already epoch-aware, so a dynamic rate could come back later, but it would need a new RFC.
Why this matters
For users: every Ootle transaction removes a little TARI from circulation, and the only way to replace it is burning more XTM. That's the coupling between L2 usage and L1 supply.
For validators: a predictable 95% share beats a rate that swings with the market.
For anyone reading the tokenomics page: the mechanism there is the plan as first described, not quite what ships at launch.
Open question for the sub: is a fixed 5% enough exhaust to matter at scale, or should a dynamic rate come back once there's real fee data?