[ANN][TESTNET][PoW] (TNR)Tenero | matmulhash v2 | Privacy coin | FCMP++

[zad112]

TENERO (TNR)
GPU-FOCUSED PROOF-OF-WORK CRYPTOCURRENCY

PUBLIC ALPHA TESTNET IS LIVE

FCMP++ and carrot is LIVE on gamma

GitHub Repository |
Downloads / Releases |
GitHub Discussions

Reddit |
Discord


🟢 Mainnet launch: 1 November 2026
🟡 Public Alpha Testnet: LIVE


Mine the testnet, run a node, benchmark your GPU, and help prepare for mainnet.

An experimental proof-of-work cryptocurrency built around modern GPU hardware, with a long-term goal of Monero-style privacy.

DISCLAIMER

Tenero is currently an experimental alpha testnet.

The project is developed by one person and has not received independent cryptographic, security, or hardware review. It should not be considered a finished cryptocurrency.

Nothing on the Tenero test network has monetary value.

The network may be reset during development, and testnet coins may be lost.

The current proof-of-work is new and has not been independently analyzed for ASIC resistance.

Tenero is inspired by CryptoNote and Monero, but it is not affiliated with, endorsed by, or part of the Monero project.


1. WHAT IS TENERO?

Tenero is an open-source proof-of-work cryptocurrency written in Rust.

The project focuses on two main areas:

• GPU-oriented proof-of-work*
  *
• Monero/CryptoNote-inspired transaction privacy
  

The first public alpha is mainly for testing the blockchain, mining algorithm, networking, and wallet software.

The goal at this stage is not to present a finished currency. The goal is to build the system, test it, find problems, and improve it.


2. PROOF-OF-WORK: MATMULHASH V2

Tenero currently uses a proof-of-work algorithm called matmulhash v2.

The algorithm is built around operations that are highly parallel and well suited to modern GPUs.

Each mining attempt:

• Uses the block header and nonce as input*

*

• Generates a 64 × 8192 INT8 matrix with ChaCha20
  
• Selects a 16 MiB slice from the proof-of-work dataset*
  *
• Performs exact integer matrix multiplication against that slice
• Folds the result into the final proof-of-work hash

Current dataset parameters:

Code:

Dataset size:        4 GiB
Number of slices:    256
Slice size:          16 MiB
Matrix:              64 × 8192 INT8
Epoch length:        100 blocks

The dataset uses a data-dependent construction and must be generated sequentially.

The intended workload combines:

GPU compute throughput and memory bandwidth

The design is aimed at modern GPUs with high memory bandwidth and hardware optimized for matrix operations.


3. ASIC RESISTANCE

Tenero does not claim that matmulhash v2 is ASIC-proof.

The current design is testing the following idea:

If each mining attempt requires a large memory read as well as substantial matrix computation, a specialized miner may still need a large amount of high-bandwidth memory and compute hardware to outperform commodity GPUs.

Each mining attempt reads a complete 16 MiB dataset slice.

At the current measured GPU performance, this represents hundreds of GB/s of equivalent dataset reads.

On an RTX 5070 Ti, the current CUDA implementation has measured approximately:

Code:

~33,000–36,000 attempts/sec
~550–590 GB/s equivalent slice reads

These figures come from one GPU and one system. They are not proof of ASIC resistance.

The project welcomes criticism, FPGA implementations, hardware analysis, and attempts to find more efficient ways to perform the computation.


4. NETWORK AND CONSENSUS

Block target: approximately 60 seconds

Difficulty adjustment: per block using a weighted LWMA-style calculation over the previous 30 blocks

Starting reward: 20 TNR

Halving interval: 525,600 blocks

Main emission: 20,000,000 TNR

Tail emission: 0.5 TNR per block

Premine: none

The alpha genesis block creates no premine. Coins on the network are created through proof-of-work mining.

Block size uses a dynamic median-based model with a penalty for oversized blocks, following design ideas used by Monero.


5. PRIVACY

The long-term privacy design is inspired by CryptoNote and Monero.

The planned transaction system includes:

• CLSAG ring signatures*

*

• Ring size 16
• Pedersen commitments*

*

• Bulletproofs+
• Hidden transaction amounts

The current alpha wallet is not Monero-level private.

It currently uses an interim CryptoNote-style output scheme while development continues toward the planned privacy architecture.

The current implementation does not yet provide all of the protections intended for the final design.

The cryptographic implementation is also unaudited.


6. NETWORKING

Tenero uses a peer-to-peer network for blocks and transactions.

Peer communication currently uses an encrypted channel based on the Noise protocol.

The alpha network includes a built-in seed server for peer discovery.

The long-term goal is to support multiple independently operated seed nodes and a more decentralized network bootstrap process.

The current alpha network is small and experimental.


7. SOFTWARE

The current release includes:

• tenerod — Tenero full node*
  *
• tenero-miner — GPU/CPU miner
  
• tenero-wallet — command-line wallet*
  *
• tenero-wallet-gui — graphical wallet
  
• tenero-seedcheck — seed verification utility
  

The GPU miner currently supports NVIDIA GPUs through CUDA.

The GPU implementation uses CUDA, NVRTC, and cuBLASLt.

AMD GPU mining is not currently implemented. Alternative miner implementations are welcome.


8. CURRENT TEST STATUS

The project currently includes:

• Rust node and blockchain implementation*

*

• GPU and CPU mining
• CLI and GUI wallets*

*

• Encrypted P2P networking
• Independent Python reference implementation*

*

• Consensus test vectors
• Fuzzing targets*

*

• Approximately 900+ automated tests

The Rust implementation is checked against the independent Python reference implementation for bit-for-bit agreement on the relevant consensus and proof-of-work calculations.

The current alpha network has been run across Windows and Linux nodes, with proof-of-work being produced and independently verified by the nodes.

The network is still very small and has not been subjected to large-scale testing.


9. HARDWARE AND MINING REQUIREMENTS

GPU mining:

NVIDIA GPU

CUDA Toolkit 13.x

Approximately 4 GiB of GPU dataset storage is required. Additional memory is used by the mining process.

Only a limited number of GPU configurations have been tested, so compatibility with other cards should be considered experimental.

CPU mining:

CPU mining is supported but is currently impractical compared with GPU mining.

Tenero is intended as a GPU-focused proof-of-work experiment.


10. DOWNLOAD

Latest releases:


https://github.com/zad112/Tenero/releases


The releases currently provide Windows and Linux packages.

The binaries are not code-signed.

Verify the SHA-256 checksum before running downloaded binaries.

Users who prefer to verify the code themselves can build the project from source.

Source:


https://github.com/zad112/Tenero



11. BUILD FROM SOURCE

Tenero is written in Rust.

Basic source build commands:

Code:

cargo build --release
cargo test --workspace

The repository contains the consensus specification, test vectors, benchmark information, threat model, network documentation, and testing documentation.


12. ROADMAP

CURRENT: PUBLIC ALPHA TESTNET

The current phase is focused on public testing of the node, miner, wallets, networking, consensus, and proof-of-work.

The alpha period is intended to identify and fix issues before the permanent network launches.

NOVEMBER 1, 2026: PERMANENT MAINNET

The current plan is to launch the permanent Tenero mainnet on November 1, 2026.

The mainnet launch is intended to mark the transition from the experimental alpha network to the permanent Tenero network.

Before launch, the priorities are:

• Expand public network testing*

*

• Test additional GPU architectures
• Improve mining performance and stability*

*

• Improve peer discovery and network resilience
• Continue consensus and security testing*

*

• Expand documentation
• Resolve known critical issues*

*

• Prepare the permanent mainnet genesis and network parameters

Longer-term development

• Replace the interim wallet output system with the planned Carrot-based design*

*

• Continue privacy development
• Expand independent node and seed infrastructure*

*

• Encourage third-party miners and alternative implementations
• Pursue independent cryptographic and proof-of-work review

The November 1, 2026 mainnet date is the current target and may change if a critical security or consensus issue is discovered before launch.


13. COMMUNITY AND DISCUSSION

GitHub Discussions:


https://github.com/zad112/Tenero/discussions


Reddit: r/Tenero


https://www.reddit.com/r/Tenero/


Discord:


https://discord.gg/QzfqaGDVcm


Use the community channels for:

• Mining benchmarks*

*

• Hardware testing
• Bug reports*

*

• Technical questions
• Protocol discussion*

*

• Suggestions
• Development discussion

For security vulnerabilities, use the repository's private vulnerability reporting instead of publicly posting sensitive exploit details.


14. LINKS

GitHub:


https://github.com/zad112/Tenero


Releases:


https://github.com/zad112/Tenero/releases


GitHub Discussions:


https://github.com/zad112/Tenero/discussions


Reddit:


https://www.reddit.com/r/Tenero/


Discord:


https://discord.gg/QzfqaGDVcm


Consensus specification:


https://github.com/zad112/Tenero/blob/main/docs/CONSENSUS.md


Benchmarks:


https://github.com/zad112/Tenero/blob/main/docs/BENCHMARKS.md


Threat model:


https://github.com/zad112/Tenero/blob/main/docs/THREAT_MODEL.md

TESTNET → MAINNET

PUBLIC ALPHA TESTNET

Current phase: testing, benchmarking, bug fixing, and network development.




PERMANENT MAINNET — NOVEMBER 1, 2026


Nothing on the current testnet has monetary value.

The testnet may be reset.

The software is unaudited.

The proof-of-work is experimental.

There is no premine and no coin sale.

Do not treat the current testnet as an investment.


The current objective is simple:

Build it. Mine it. Test it. Break it. Improve it.

Then, if the network is ready:

Launch it.

Feedback, benchmarks, criticism, code review, hardware analysis, and bug reports are welcome.

[zad112]

# 📦 Tenero `v0.1.0-alpha.4` is out

**Download:** https://github.com/zad112/Tenero/releases/tag/v0.1.0-alpha.4
Windows zip and Linux tar.gz. Check your file against `SHA256SUMS` before you run it.

**What changed**
One fix, found by running alpha.3 on the real network:
• A node that the seed connects to now asks the seed for addresses, and refreshes that link every 30 minutes until it has three outbound peers that aren't seeds. In alpha.3, a reachable node could end up stuck on the seed with no peers of its own, which is what alpha.3 was meant to prevent.
• Nothing else changed in the programs.

**Do I have to upgrade?**
No. The network, chain, rules and wire protocol are the same. alpha.1 to alpha.4 nodes are on the same chain and work together. Upgrade if you run a node that accepts inbound connections ("Let other nodes connect to me").

**Honest limits**
• The fix is covered by the program's own tests but has **not been tried on the real network**.
• GPU-tested by the author on one machine only (RTX 5070 Ti, about 34,000 attempts/s). Nothing is known about other cards.
• Linux: only the node has been run by hand. The Linux miner, wallet and wallet app have not been run.
• Your antivirus may flag `tenero-miner` as a coin miner. It is a miner, and nothing mines unless you start it. Check the checksum.

**Still a test release.** Unaudited, one developer, no value, and the network can be reset.
Official notices: only the pinned GitHub issue #1 (https://github.com/zad112/Tenero/issues/1). Anything claiming to be a notice elsewhere is not from the project.

[zad112]

TENERO v0.2.0-beta.1
BETA TESTNET IS NOW LIVE

Download v0.2.0-beta.1

BETA TESTNET / NEW NETWORK

Tenero v0.2.0-beta.1 is now available.

This release marks the move from the alpha network to a new beta testnet. The beta network uses a fresh genesis block and a new chain ID, so it is separate from the alpha chain.

Important: Alpha and beta coins cannot be transferred between networks.

A wallet created on the alpha network can be restored on beta with the same 24-word seed, but it will have an empty balance on the new chain.

Alpha nodes running v0.1.0-alpha.4 or earlier cannot follow the beta chain.


1. TRANSACTION CAPACITY CHANGES

The beta network replaces the previous alpha limit of 32 inputs per transaction with a 75,000-byte transaction size limit.

This allows larger transactions when needed.

Testing has reached:

Code:

Up to 95 inputs to one recipient
Up to 93 inputs with 16 outputs
16 outputs maximum
64 KiB maximum proof field

Each input is approximately 772 bytes and contributes to the transaction fee.

The change is intended to make transactions involving many small pieces more practical.


2. PAYMENT SPLITTING AND PIECES

The wallet can now split payments that do not fit into one transaction.

Payments to more than 15 recipients, or payments requiring more pieces than one transaction can carry, can be split automatically across multiple transactions.

The wallet tracks the separate pieces that make up a balance and handles the required transactions.

The CLI wallet also adds:

Code:

tenero-wallet pay-many --file

The file uses this format:

Code:

ADDRESS AMOUNT

If a payment cannot be completed immediately because a newly created piece must mature first, the wallet reports the situation instead of silently discarding anything.


3. COMBINING SMALL PIECES

Mining rewards and other payments can leave a wallet with many small pieces.

The beta release adds tools for combining them into fewer, larger pieces.

The GUI wallet now includes Combine pieces.

The CLI wallet provides:

Code:

sweep
combine --pieces N

Both options show the resulting transaction and fee before sending.

The resulting piece becomes spendable after the normal approximately 10-block waiting period.


4. FIRST VERSION OF MINING POOLS

Beta introduces the first version of the Tenero mining pool system.

New components:

Code:

tenero-pool
tenero-poolcheck

Miners can connect to a pool with:

Code:

tenero-miner --pool

The wallet application also includes:

Code:

Mining → On a pool

A miner does not need to run its own node to mine through a pool.

A node is still required to receive and spend pool payouts.

The pool protocol is documented separately and can be checked with:

Code:

tenero-poolcheck

The miner pins the pool's public key to prevent an intermediary from silently replacing the pool.


5. BUILT-IN BETA TEST POOL

A test pool is available on the beta network:

Code:

195.26.244.245:38335

Use the built-in pool with:

Code:

tenero-miner --pool default

The current test pool uses PPLNS.

It currently:

• Charges no pool fee
• Pays network transaction fees itself
• Pays miners approximately once per hour
• Uses a minimum payout of 0.1 TNR

Important: This is an experimental pool operated by the developer on a single server.

It has not been independently reviewed and has only been tested with one miner so far. It should not be treated as a production mining pool.

The pool operator can see your mining address and IP address.


6. NETWORK CHANGES

The beta network uses separate ports:

Code:

Control: 38342
P2P:     38343

The built-in beta seed is:

Code:

195.26.244.245:38343

The beta seed, like the previous alpha seed, is currently operated by the developer.

The long-term goal is to support multiple independent nodes and seed servers.

Running your own node and adding additional seeds is encouraged.


7. SOFTWARE INCLUDED

The beta release includes:

• tenerod — full node
  
• tenero-miner — GPU/CPU miner
  
• tenero-wallet — CLI wallet
  
• tenero-wallet-gui — GUI wallet
  
• tenero-seedcheck — seed verification utility
  
• tenero-pool — mining pool
  
• tenero-poolcheck — pool protocol verifier
  

Important: The node and applications must use the same version.

The beta release changes the control interface between the node, wallet, miner, and application. Older alpha applications cannot communicate correctly with a beta node.

Upgrade the complete software set together.


8. TEST RESULTS

The current beta GPU implementation has been tested on an NVIDIA GeForce RTX 5070 Ti.

Code:

Driver:        617.14
CUDA Toolkit:  13.4
GPU:           RTX 5070 Ti

The GPU engine's CPU comparison tests passed.

An end-to-end consensus test also mined 20 blocks using the real beta network parameters. Every block was independently verified by a CPU node.

Measured performance on the test system:

Code:

Batch 32:   32,323 attempts/sec
Batch 64:   33,646 attempts/sec
Batch 128:  35,472 attempts/sec
Batch 256:  36,061 attempts/sec

These results come from one GPU and one test run. They should not be treated as expected performance for other hardware.

Please post your own results.


9. CURRENT LIMITATIONS

Tenero beta is still experimental.

Current limitations include:

• One built-in beta seed
• One developer-operated test pool
• Very limited independent network participation
• Limited GPU hardware testing
• No independent cryptographic audit
• No independent ASIC or hardware analysis
• No independent security review

The Linux wallet GUI and Linux GPU miner have not yet been fully tested on desktop Linux systems.

The pool has also only been tested under very limited conditions.

Known issues remain in the repository, including security and operational limitations.

Read KNOWN_ISSUES.md and the threat model before running anything important.


10. THIS IS STILL A TEST NETWORK

The beta network is experimental.

Nothing on it has monetary value.

The network may be reset, and coins may disappear.

The software is unaudited.

The proof-of-work is still experimental.

Do not use keys, funds, or data that you cannot afford to lose.


11. WHAT WE NEED NOW

This is the most important public testing phase so far.

Testing is especially needed from people who can provide:

• Benchmarks from additional NVIDIA GPUs
• Independent nodes
• Pool testing
• Large and multi-recipient payment testing
• Windows and Linux testing
• Alternative miners or pool software
• Protocol, consensus, networking, and security testing

Report reproducible bugs through GitHub Issues.

For security vulnerabilities, use GitHub's private vulnerability reporting.


12. MAINNET TARGET

The current plan remains to launch the permanent Tenero mainnet on November 1, 2026.

The beta period is intended to test the network under increasingly realistic conditions before that launch.

The date may be delayed if critical problems are discovered.

DOWNLOAD


https://github.com/zad112/Tenero/releases/tag/v0.2.0-beta.1


COMMUNITY

GitHub Discussions

r/Tenero

Discord


Build it. Mine it. Test it. Break it. Improve it.

The beta is now open.

[zad112]

TENERO v0.2.0-beta.2
BETA TESTNET UPDATE

Download v0.2.0-beta.2

BETA.2 — PROOF-OF-WORK UPDATE / HARD FORK

Tenero v0.2.0-beta.2 is now available.

This is a relatively small release in terms of user-facing features, but it contains an important change to the proof-of-work.

The beta network will hard fork at block 500.

You must upgrade to v0.2.0-beta.2 before the chain reaches block 500.

Nodes running v0.2.0-beta.1 or earlier will stop at block 499 and will reject beta blocks from height 500 onward.

Blocks 0–499 remain compatible between the two versions.


1. A PROBLEM WAS FOUND IN MATMULHASH V2

During testing and optimization of the miner, a weakness was discovered in the original beta proof-of-work.

The previous algorithm selected a single 16 MiB slice from the 4 GiB dataset for each attempt.

Because miners control the nonces they try, multiple nonces could be deliberately chosen to target the same slice. This allowed the memory access cost to be amortized across many attempts.

Even worse, it was possible to preferentially mine using only one slice of the dataset instead of requiring access to the entire 4 GiB dataset.

This meant the proof-of-work was becoming primarily compute-bound rather than memory-bound.

That is not the behavior the algorithm was intended to produce.

Rather than ignore the problem, beta.2 changes the consensus proof-of-work.


2. GATHERED PROOF-OF-WORK

From block 500 onward, each mining attempt uses a new gathered-memory access pattern.

Instead of reading one contiguous 16 MiB slice, the matrix multiplication now gathers 2,048 individual 8 KiB columns selected across the full dataset.

The goal is to prevent miners from repeatedly reusing the same small portion of the dataset and to make attempts share substantially less memory.

The important property is that the memory requirement is once again part of the cost of each attempt.

The dataset construction, final fold, block ID, and cheap proof-of-work check remain unchanged.

The new consensus rule is documented in:


https://github.com/zad112/Tenero/blob/main/docs/CONSENSUS.md


The implementation is also checked against golden vectors generated by the independent Python reference implementation.


3. MINER PERFORMANCE

While fixing the proof-of-work, the miner was also substantially optimized.

On the same RTX 5070 Ti used for previous benchmarks, the old implementation was around:

Code:

~35,000 attempts/sec

The optimized miner reaches approximately:

Code:

~120,000–125,000 attempts/sec

on the pre-fork beta/alpha workload.

From block 500 onward, the new gathered proof-of-work measures approximately:

Code:

~45,000 attempts/sec

on the same RTX 5070 Ti.

The lower number after the fork is expected because each attempt now performs more difficult memory work.

Raw attempts/sec should not be compared directly across the fork.

What matters is the relative amount of work required to produce a valid block.

The new proof-of-work also uses approximately 400 MiB more VRAM than the previous version.


4. GPU VALIDATION

The new GPU implementation has been tested against the CPU implementation bit-for-bit.

Tested hardware:

Code:

GPU:           NVIDIA RTX 5070 Ti
Driver:        617.14
CUDA Toolkit:  13.4

The GPU test suite successfully verified:

• All 256 dataset slices
• The new gathered proof-of-work vectors
• Bit-for-bit agreement between GPU and CPU implementations

End-to-end mining tests also produced 20 blocks on the GPU, with all 20 independently accepted by the node's CPU verification.

A second test across the proof-of-work fork produced another 20 blocks, again with every block accepted and none refused.


5. IMPORTANT — UPGRADE BEFORE BLOCK 500

Please upgrade before the beta chain reaches height 500.

The fork height is fixed in the program.

If enough nodes do not upgrade before activation, the beta network can split into two separate chains.

Upgrade:

• tenerod
• tenero-miner
• tenero-wallet
• tenero-wallet-gui

The beta release is distributed as one software package, so upgrading the complete installation together is recommended.

You can check your current height with:

Code:

tenerod status

The alpha network is not affected by this fork.


6. WHY THIS MATTERS

One of the main reasons for running a public testnet is to find exactly these kinds of problems.

The original proof-of-work looked reasonable, but real-world mining exposed an optimization that changed its actual economic properties.

The fix is now part of the beta consensus rules.

This is also why I am continuing to avoid claiming that Tenero's proof-of-work is "ASIC-proof."

The new design has had no outside hardware review, and there may be additional optimizations or weaknesses that have not yet been discovered.

Finding those now is the purpose of the testnet.


7. CURRENT STATUS

Tenero remains an experimental beta testnet.

Current priorities are:

• More independent nodes
• More GPU hardware testing
• Longer mining runs
• Testing the new gathered proof-of-work
• Pool testing
• Consensus and networking testing
• Finding additional weaknesses before mainnet

The current testnet has no monetary value and may still be reset.

DOWNLOAD


https://github.com/zad112/Tenero/releases/tag/v0.2.0-beta.2


COMMUNITY

GitHub Discussions

r/Tenero

Discord


Keep testing. Keep benchmarking. Keep finding problems.

The goal is to find them before mainnet, not after.

[zad112]

TENERO v0.2.0-beta.4
BETA TESTNET UPDATE

Download v0.2.0-beta.4

BETA.4 — GPU MINER SIMPLIFICATION + NEW BLOCK EXPLORER

Tenero v0.2.0-beta.4 is now available.

This is a relatively minor release, but it makes two important improvements for testers:

• The NVIDIA miner no longer requires the CUDA Toolkit
• A new local block explorer has been added

There are no consensus changes in beta.4.

The proof-of-work, block rules, transaction rules, and P2P protocol remain the same as v0.2.0-beta.3.

A beta.3 node and a beta.4 node can follow the same chain and communicate with each other.

If you are still running beta.1 or earlier, however, you must already be on the beta.2+ chain because of the block 500 proof-of-work fork.


1. GPU MINER NOW ONLY NEEDS THE NVIDIA DRIVER

One of the main goals of beta.4 was to simplify GPU mining.

The miner no longer requires the CUDA Toolkit.

The GPU code is now compiled directly into the miner, and the NVIDIA driver loads it at runtime.

The miner no longer depends on:

Code:

NVRTC
cuBLASLt
CUDA Toolkit

The 8-bit matrix multiplication used by the proof-of-work is now implemented directly in the miner's own GPU code.

The result has been checked bit-for-bit against the CPU implementation using the existing golden vectors and GPU tests.

Requirements:

Code:

NVIDIA RTX 30 series or newer
Compute Capability 8.0+
CUDA 13 compatible driver
R580 or newer

Older NVIDIA cards such as RTX 20-series and GTX 16-series are now rejected with an appropriate message rather than attempting to run unsupported code.

No CUDA Toolkit installation is required for GPU mining anymore.

This should make setting up a test miner considerably easier.


2. NEW: TENERO BLOCK EXPLORER

Beta.4 also introduces:

Code:

tenero-explorer

The explorer is designed to provide a local window into a Tenero node.

It currently displays:

• Current block height
• Next-block difficulty
• Estimated network hashrate
• Mean block time
• Coins emitted
• Current block reward
• Transactions waiting in the node's mempool
• Transaction fees, fee rates and sizes
• The latest 30 blocks

It automatically refreshes every 5 seconds.

The explorer can be run against the node used by the wallet application, or against another local beta node.

For example:

Code:

tenero-explorer --data FOLDER --network beta

The explorer is intentionally read-only.

It cannot send transactions, modify the node, or communicate with another computer. It communicates with the node's local control interface.

The estimated network hashrate is only an estimate based on recent blocks and should not be treated as an exact measurement of network mining power.


3. NODE CONTROL INTERFACE

To support the explorer, the node now exposes three additional local control queries:

Code:

headers
mempool
chain_stats

The node also records when transactions were received into its local transaction pool.

These additions are for the explorer and do not affect consensus or mining behavior.

The additional information exposed is limited to transaction IDs, fees, sizes, and receive times. No keys or transaction amounts are exposed through these new explorer queries.


4. TESTING

The new miner has been tested against the CPU implementation using the existing golden vectors.

The GPU test suite currently verifies:

• All 256 dataset slices
• Both proof-of-work designs at the real parameters
• Bit-for-bit agreement with the CPU implementation

The test suite completed with:

Code:

1,106 passed
0 failed

The GPU mining tests on the RTX 5070 Ti produced:

Code:

20 blocks on GPU
20 blocks independently accepted by CPU verification
20 additional blocks across a fork

Test hardware:

Code:

GPU:           NVIDIA RTX 5070 Ti
Driver:        617.14
CUDA Toolkit:  not installed

The beta proof-of-work remains approximately:

Code:

~43,500 attempts/sec

[zad112]

TENERO v0.3.0-gamma.1
GAMMA TESTNET — NEW NETWORK / FCMP++ / CARROT

Download v0.3.0-gamma.1

A NEW STAGE FOR TENERO

Tenero v0.3.0-gamma.1 is now available.

This is a major milestone for the project. Gamma introduces a new blockchain network with FCMP++ and Carrot-based wallet functionality from genesis.

Rather than continuing the beta chain, gamma starts with a fresh genesis block and a new chain ID. The beta network is closing, and the existing seed servers and test pool are being switched over to gamma.

The goal is to begin testing the new privacy architecture, wallet functionality, consensus rules, and mining software together on a fresh network.

This is still an experimental testnet, not a permanent mainnet launch.


IMPORTANT — READ BEFORE UPGRADING

Gamma is a new and separate blockchain, not a fork of beta.

• The new network starts from a fresh genesis block.
• There is no premine; the genesis block creates no coins.
• Nothing transfers from alpha or beta to gamma.
• The new software runs gamma, dev, and test networks, not alpha or beta.
• All node, miner, wallet, GUI, explorer, and pool software must use version 0.3.0.

Your existing 24-word beta wallet seed can be used to restore a wallet on gamma, but the restored wallet will start with an empty balance on the new chain.

Do not expect beta testnet coins to carry over.

The new gamma addresses begin with:

Code:

TENg

The beta network is closing as the gamma network comes online.


1. FCMP++ — FULL-CHAIN MEMBERSHIP PROOFS

One of the biggest changes in gamma is the introduction of FCMP++.

Traditional ring-signature systems hide a spent output among a limited set of possible outputs. Tenero's previous design used a ring size of 16.

FCMP++ takes a different approach.

Instead of proving that a spend belongs to a small ring of possible outputs, the spender proves membership against the set of outputs on the chain.

The intended privacy architecture includes:

• Full-chain membership proofs
• Hidden transaction amounts using Pedersen commitments
• Bulletproofs+ range proofs
• Private spending through the FCMP++ construction

The FCMP++ implementation uses Monero's Rust code from monero-oxide, pinned to the commit used by Monero's own FCMP++ test network.

However, this must be understood in context.

Monero has not deployed FCMP++ on its own main network, and the relevant code is only partly audited. Tenero's use of it has not received an independent audit.

The presence of FCMP++ does not mean gamma is proven private or secure.

There are also practical privacy limitations during the early life of a chain. When there are few outputs, the anonymity set is small. The timing of transactions can still reveal information, particularly during the initial mining period.


2. CARROT ADDRESSES AND WALLET SUPPORT

Gamma also introduces the planned Carrot-based wallet architecture.

Carrot is designed to improve wallet functionality and privacy while supporting features such as subaddresses and view-only wallets.

The gamma implementation includes:

• Carrot addresses
• Subaddresses
• Integrated addresses with payment IDs
• View-only wallets
• Multiple accounts derived from the same 24-word seed
• Improved wallet history

The Rust implementation was written from the Carrot specification because a Rust implementation was not available for this project to use.

The implementation is tested against Monero's C++ implementation for bit-for-bit agreement on keys, addresses, outputs, scanning, and key images.

These tests are useful, but they are not a substitute for independent review.

The Carrot implementation, the surrounding curve-tree bookkeeping, and the integration with the wallet and consensus rules remain unaudited.


3. VIEW-ONLY WALLETS

Gamma introduces view-only wallets.

These allow someone to inspect wallet activity without giving the wallet the ability to spend funds.

Two viewing modes are supported:

• View-all: sees incoming and outgoing payments and the true wallet balance.
  
• View-received: sees incoming payments only.
  

A view-only wallet does not possess the spend key and cannot perform operations requiring it.

The GUI can display a view key after the wallet has been unlocked. A view-only wallet can then be created from the welcome screen or restored through the CLI:

Code:

tenero-wallet restore-view

View keys are secrets and should only be shared with people you intend to authorize to inspect the corresponding wallet activity.


4. MESSAGE SIGNATURES AND PAYMENT PROOFS

Gamma includes message-signing and payment-proof functionality.

These are custom constructions for Tenero because the Carrot specification and Monero's implementation do not yet define equivalent Carrot message signatures and payment proofs for this project to use directly.

The wallet includes:

• Message signatures using the `TENsig1...` format
• Payment proofs using the `TENpay1...` format
• Verification tools for checking the proofs

An independent Python reference implementation is used to check the Rust implementation byte-for-byte.

However, these signature and payment-proof constructions are our own and have not been independently reviewed.

Payment proofs can reveal the relevant payment information to whoever receives the proof. They should not be treated as a way to preserve privacy from the recipient or verifier.

Documentation:

WALLET_PROOFS.md


5. NEW CHAIN PARAMETERS

The gamma network starts with its own genesis block and chain identity.

Network: gamma

Premine: none

Proof-of-work: gathered-memory matmulhash design, active from block 0

Starting target: 2^237

Starting address prefix: TENg

Control port: 38352

P2P port: 38353

The starting target is intended to correspond to approximately 524,000 attempts per block at the initial difficulty. Actual block timing will depend on the available mining power.

The gathered proof-of-work introduced in beta.2 is used from the beginning of gamma, rather than activating after a fork height.

The gamma network is separate from beta and has its own block history.


6. PRUNING AND BLOCK STORAGE

Nodes now prune old proof data by default.

The default configuration retains the proofs for the most recent 5,500 blocks, reducing long-term disk growth.

For operators who want to retain the complete chain data, archive mode can be enabled with:

Code:

prune_keep = 0

An archive node is recommended for seed infrastructure and for the node used by the block explorer.

Pruning behavior is intended to make running a node more manageable without requiring every operator to retain every historical proof indefinitely.


7. BLOCK WEIGHT AND TRANSACTION CAPACITY

Gamma also introduces a block-weight model designed to allow the network to grow as demand increases.

Transaction proofs count as one quarter of their byte size for block-weight accounting.

The rules allow block weight to grow with demand up to:

Code:

Maximum block weight: 12 MiB
Equivalent real bytes: up to 48 MiB

The long-term block-size adjustment uses a median-based mechanism similar in principle to Monero's approach.

The maximum is a protocol limit, not a claim that the current network can sustain blocks of this size in practice.

No large-scale test has yet demonstrated that maximum capacity.


8. MINING, COMPACT BLOCKS AND POOLS

The gamma release includes the node, miner, wallet, GUI wallet, block explorer, seed utility, pool, and pool verification utility.

Compact block templates have also been introduced.

Instead of requiring a remote miner to receive a full block template containing every transaction, the node can provide a compact template using the block header, reward, and transaction IDs.

This allows remote miners and pool miners to work with the full protocol block-weight limit without the old 3 MiB template cap.

The included pool is still an experimental developer-operated service. It runs on one operator's infrastructure, has not been independently reviewed, and has not been tested at scale.

Pool payments are not guaranteed. The pool operator retains the block rewards, and there is no independent mechanism guaranteeing that the operator will pay miners.

Do not use the pool as though it were a trusted or production service.


9. NETWORK BOOTSTRAP

Gamma has two built-in seed endpoints:

Code:

195.26.244.245:38353
194.238.27.60:38353

These run on two machines, but both are controlled by the same developer. This is not the same as having three or more independent seed operators.

The project still needs independent node operators and seed infrastructure.

Running a node yourself is one of the most useful ways to help test the network.


10. BUG FIXES FROM BETA TESTING

Gamma also includes fixes for problems discovered during beta testing.

One important issue involved nodes that were far behind the chain.

Previously, a syncing node could receive transactions, judge them against its old chain, and incorrectly penalize peers for sending transactions that were valid on the current chain. This could eventually leave the node with no peers while incorrectly reporting that it was synchronized.

The new implementation avoids judging new transactions against an outdated chain during synchronization. It also reports when a node has no peers and therefore cannot determine whether it is up to date.

Other changes improve duplicate transaction handling and the time needed to quote fees for payments involving many inputs.

These changes are based on testing and feedback, but some of the new network fixes have been verified through simulation rather than extensive real-world gamma operation.


11. TEST STATUS AND KNOWN LIMITATIONS

The gamma release passed:

Code:

Automated tests: 1,151 passed
Failed:          0
Skipped:         37

The skipped tests include GPU-dependent tests and longer tests that are run manually.

The release also includes end-to-end tests covering mining, transactions, real FCMP++ proof verification by a node, view-only wallets, message signatures, payment proofs, pool connections, and wallet application logic.

The RTX 5070 Ti GPU miner has been tested by the developer. Additional hardware support has been compiled for NVIDIA RTX 30-series and newer GPUs, but those other architectures have not all been tested physically.

The following limitations are especially important:

• The FCMP++ implementation has only partial upstream auditing, and its use in Tenero has not been independently audited.
• The Carrot implementation and curve-tree bookkeeping are unaudited.
• Message signatures and payment proofs are custom constructions that have not been independently reviewed.
• The network is brand new, and real-world gamma testing has only just begun.
• The seed servers and pool remain under one operator.
• The Linux GUI and GPU miner have not yet been fully tested.
• Early-chain privacy is limited by the small anonymity set and transaction timing.

Please read the project's known issues and threat model before participating:

KNOWN_ISSUES.md

THREAT_MODEL.md


12. DOWNLOAD AND UPGRADE

Release:

Tenero v0.3.0-gamma.1

Source code:

GitHub Repository

All gamma components should be run at version 0.3.0:

• tenerod
• tenero-miner
• tenero-wallet
• tenero-wallet-gui
• tenero-explorer
• tenero-pool
• tenero-poolcheck

The release packages include the documentation, running instructions, pool instructions, and wallet proof documentation.

The binaries are not code-signed. Verify the SHA256 checksum before running downloads, or build from source.


13. COMMUNITY / REPORTING

GitHub Discussions:

https://github.com/zad112/Tenero/discussions

Reddit:

https://www.reddit.com/r/Tenero/

Discord:

https://discord.gg/ZwMGXwQdCJ

Report ordinary bugs through GitHub Issues.

For security problems, use GitHub's private vulnerability reporting rather than publicly posting exploit details.


14. MAINNET PLANS

The previously stated target for permanent mainnet has been November 1, 2026.

Gamma is a new experimental network with substantial privacy and wallet changes, so the priority now is to test it thoroughly and find problems before any permanent launch.

The date remains a target, not a guarantee. Critical consensus, cryptographic, or security issues must take priority over a fixed schedule.

GAMMA IS A TEST NETWORK

Nothing on this network has monetary value.

The network may be reset at any time.

The software is unaudited.

The privacy architecture and custom wallet proofs are experimental.

There is no premine and no coin sale.

Do not use gamma to store anything you cannot afford to lose.


The objective remains simple:

Build it. Mine it. Test it. Break it. Improve it.

Feedback, code review, GPU benchmarks, independent node operation, privacy analysis, and bug reports are welcome.