With this contribution, I want to share my idea of a Radix Homepage, how I personally would love it to be.
I was never really intrigued by the old one, because I think a Homepage should tell the viewer fast and directly what he’s looking at, and why that matters.
This should be a piece of discussion, a seedling, a starting point, from where we all share ideas so it can evolve into s.th. the majority feels should represent Radix as a Webpage. I might have gotten details wrong and as I’m not english native, the texts for sure need correction. Even the overall structure is just a snapshot of a picture in my head, we might come up with something completely different .
I invite everybody that knows how to design websites to take the texts here and put them in some nice, shiny, elegant, appropriate website, using radix symbols and colors, and present it, and then we can discuss together which approach we like most .
The basic idea is, that it should be at first glace a very simple page, not much text, almost empty, and then the visitor, bit by bit, opens windows to get more details and links he can follow through.
In this text version, I was fighting with formatting stuff after importing it from a docx file… But I think the idea gets clear, I tried to indent the parts that only open by clicking the bold lettered headlines. Central keywords that I underlined should link to already existing pages of the Radix docs or knowledge database.
The Homepage would just have the 4 words in bold letters, and the text after “THE MISSION”.
Everything else only opens by user interaction. (Sorry to foxy for copying his style of one-worder-chapters, I kind of liked that. We can in the end decide for something else, of course…)
The last chapter, the “community shout-out” is an emotional, not very professional piece. The community should decide if it can have a place on the homepage.
I definitely think it should. It could either be positioned inside the last link “The Government” or be put aside, directly on the bottom of the main page. Although being unprofessional I think its an honest assessment that addresses issues that all human visitors of the page will share.
And in our new world where everything is done by AI, maybe some personal, real human expression sets a charming contrast.
Ok, so here it is, my idea of the future RADIX Homepage:
- ---------------------------------
THE MISSION
To build The Universal Asset Layer.
The future worldwide infrastructure for storing, transferring and handling assets, identity and ownership. Easy to use. Safe. A decentral, public good, capable of on-boarding all assets worldwide, and allow for their seamless inter -operation.
THE REQUIREMENT
THE SITUATION
THE GOVERNMENT
- ---------------------------------
A click on “The strategy”, “The situation”or “The government” will open floating windows with the key points. In the window of “The situation” further windows open either while the mouse floats over an keypoint, or permanent, I’m not sure whats better, ha ve to try out
.- ---------------------------------
THE REQUIREMENT
1. A protocol that scales linearly, more nodes add more throughput.
2. Easy, intuitive and safe to use.
3. Real decentralization, geo distributed Validators have to run on commodity hardware
THE SITUATION
A short overview
The journey of Radix began more then 10 years ago, as the founder Dan Hughes set out to solve the blockchain trilemma and spend more then a decade R&D to create a system that would fulfill the requirements and complete the mission.
After a long road with a lot of ups and down, he died in July 2025 of natural cause and left a passionate community that is resolved to carry the mission to the end.
Since the beginning of 2026 The Radix Foundation is in the process of winding down and handing governance and treasury to the Radix DAO, which will be owned and governed by the XRD token holders.
The Network today
Since September 2023 the Babylon upgrade of the Radix network is life.
It’s a full fledged smart contract distributed ledger protocol, running on 100 geo-distributed validators and using a HotStuff BFT consensus with a delegated stake model as sybil protection.
It can handle about 50 complex transactions per second and was always meant to be an interim solution until the Xi’an upgrade to a fully s harded network gets live.
The virtual machine, the Radix Engine is written in Scrypto, a programming language based on Rust, that was developed especially for serving the needs of decentral finance and a sharded smart contract dis tributed ledger platform.
A Hacken Audit in October 2023 gave it an incredib le 10.0 out of 10.0 points.
Like the Game Engine enforcing the laws of physics in a Computer Game, the Radix Engine enforces the expected behavior of assets in DEFI applications.
The Radix Engine works as a pure state machine, which allows for deterministic behavior with predictable outcomes. Things that need heavy work-around with many attack surfaces in other L1 protocols just come naturally and easy for Radix, as the full stack was built from scratch with our mission in mind.
-
Asset oriented [link to Radix docs]
-
All objects like Tokens and NFTs are native assets. They are not Smart Contracts that have to be asked if an address appears in their spreadsheet .
All assets are real objects that live in an account, with clear defined rules about transferring, minting, freezing that are enforced by the Radix Engine and which are clearly visible. Hidden freeze or mint functions are not possible.
This allows for a separation of business logic and asset behavior. Developers can concentrate on developing applications without worrying about how to enforce behavior rules of involved assets.
-
Human readable transactions. [link to Radix docs]
The protocol itself presents the user the TransactionManifest, instructions in clear language which assets are to be moved in which way, before signing.
Transaction guarantees can be set and are enforced at protocol level, is the expected outcome not met, the transaction aborts, independently of the application creating the transaction.
A transaction can involve many states, accounts, and conditions. The Radix Engine guarantees that they atomically either all execute and succeed, or not at all. Half-states or roll-backs don’t exist.
-
Smart accounts are native to the protocol, allowing for seed-less handling and recovering of accounts
MultiFactorAuthentication allows to customize the rules for controlling and recovering accounts. Users can build their individual security shield for each account, using a combination of all sorts of security factors, like hardware wallets, phone, Ledger, Arculus Card, an off‑device mnemonic or another trusted person, even in combination with time criteria.
-
Fee delegation
Fee delegation is implemented at protocol level, no smart contract workaround.
No need to hold XRD in a wallet that has to sign a transaction, just tell the Radix Engine which account gonna pay
{maybe some nice ex amples}
-
Intent based transactions
A transaction involving one or several accounts can be signed in several steps. If the first account signs, the Tx stays pending, until all necessary signatures happen. It fails at time-out, or if the transaction guarantees are not met, otherwise executes atomically.
All this enforced by the protocol, without involving any smart contract logic
-
Authentication system using personas and badges
Instead of deciding access control based on who called, as in most traditional block chains, Radix implements a role based system.
Comparable to the different rights an administrator or a normal user has when using a computer, developers set rules about which roles are allowed to perform different actions. (e.g., accessing an administrator-only method on a component, or minting more supply of a resource).
The proof to have a certain role is done by “badges”. Badges are the mechanism by which actors demonstrate that they are able to meet a role. Badges can be proofs of resources (like showing that you have access to a membership token), NFTs that can be soulbound or transferable in an account, or they can be virtual things created automatically by the system (like a proof that a certain signature was present in the transaction).
As all these settings are visible to on- and off ledger tools, the consumer can understand the security pattern of an unfamiliar component or resource without having to delve into reading any code.
Unique in the crypto space, Radix’s authorization model finally allows for a proper separation of concerns between business logic and access rules, giving applications the flexibility to start with a simple control scheme and grow into something more complex later on — without having to hand-roll a bespoke solution, and without having to rely on the demonstrably dangerous “what’s the source of this request” pattern whic h plagues the industry
-
Developer royalties
To incentivize contribution to the ecosystem, every deployed blueprintt [on-ledger template of smart contract functionality that can be instantiated into components, the radix version of smart contracts] can enforce a royalty fee every time it gets called.
This will automatically be added to the transaction fees and is enforced at protocol level.
All the above mentioned points make Radix a cutting edge protocol with properties that are truly unique in the space.
A full codebase audit passed extremely well in a Zellic Audit in May 2025. Especially the badge-based security and access control model got praise for beeing a "very clean and simple system, and it is incredibly difficult to introduce access-control issues through user error.¨
AI integration profits heavily of the clear structure of Rust/Scrypto, the human readable TransactionManifest and intend based Transactions.
A Radix Rust SDK lets developers build authentication backends, transaction tooling, and wallet integrations entirely in pure Rust. AI agents can pair a Radix wallet and request signatures through the SDK’s transports. Combined with native ROLA verification and Gateway signing, this positions the Rust SDK as a foundation for agentic Radix tooling that runs entirely outside a browser.
The way to define roles, ownership and access rules via badges and personas, facilitate KYC requirements and institutional adoption.
Radix has some unique and native properties, that make it predestinated for a future where AI bots handle transactions and where institutions, which need their KYC rules implemented, adopt Web3.
All this is live, working and getting developed and advanced every day.
We invite you to try it out.
[List of nice, important Radix apps
- Radix Seal
- Ai Demo
- Radlo cks…
…lets agree together which apps should show up here]
What is missing: the last step, unlimited throughput, the ability to onboard the world, without limits:
Hyperscale, the end game, where throughput scales linearly with compute.
-
Introduction
After spending years trying out different approaches to solve the blockchain trilemma, Dan Hughes, the late founder of Radix, spent most of his last years developing Cassandra, a research network to test the possibilities and limits of a fully sharded network, especially how to maintain atomic commitment and atomic composability on a sharded network running on commodity hardware (4-core, 8 GB RAM)
Although incomplete, it already showed impressive results of several 100.000 Transactions per seconds in a community run public test.
The community inherited the codebase and a community member started to implement a clean, production grade rewrite from scratch in Rust.
This development happens in public, with daily exchance in telegram, daily commits on github and weekly reports.
Hyperscale is expected to go live on mainnet with the Xi’an upgrade expected in Q4/2027.
-
An overview:
Hyperscale is a fully sharded network, where every shard is responsible for a part of the network state. The states are organized in a Jelly Merkle Tree, and a shard is always responsible for a whole branch of the tree with all its leaves/substates.
The shardspace expands and shrinks dynamically, depending on demand.
If a shard hits a system defined limit of storage or cpu use, it splits in two, in a clear, deterministic way, two subbranches of the JMT build the new shards. When two shards merge the same process happens in reverse.
A slow ticking beacon chain determines for every epoch which validators are responsible for which part of the JMT.
The beacon chain doesn’t tell anybody who is responsible for what. Every beacon block consist of information each shard contributes at the end of every epoch. A function folding the beacon chain results in the assignement of each validator and its place in the JMT and other topological properties of the network.
So every validator can calculate for itself for any time or epoche for which states it is or has been responsible.
This is made possible by the pure deterministic design.
Every epoch one shard member is randomly shuffled out and another one is shuffled in. The new shard-member gets one epoch to sync before starting to participate in validating transactions.
Important to be mentioned:
No transaction ever touches the beacon chain, it is a purely coordinative chain, building one block per epoch time, e.g. 30 min, with the task to allow every validator to calculate for himself who is responsible for what , who gets jailed, shuffled in, shuffled out, which shards split, which merge…
-
The transactions journey
Now to the main problem of sharded networks: How can we guarantee that a transaction whose states (inputs) live in different shards executes “all-or-nothing”, meaning either it gets executed over all concerned shards, or aborted everywhere, never ever in between.
A transaction getting into the mempool at first declares which states or inputs are involved.
Now every validator can calculate for himself which shards are touched and which validators are responsible.
This is a pure deterministic calculation by folding the beacon chain, it needs no messaging, and every honest replica always comes to the same result.
The transaction gets routed to the concerned shards and put in a respective block. BFT voting per shard agrees on having the transaction in the block, the resulting voting certificate including the states/inputs and block header gets sent to all other shards that are concerned.
If all shards vote successfully and include their part of the transaction in their block, all the validators have the byte wise exactly same information, a list of all the touched states that are proofable included in a block.
Validators in all shards then run the Radix Engine and execute the transaction. As this is a purely deterministic process in a final state machine, all the results on all the validators are exactly the same, to the byte.
After execution the ExecutionCertificate is as well exchanged between all concerned validators.
As soon as a validator received all ExecutionCertificates of all touched shards, he has the proof (!) that all shards executed the transaction with the same result, and only if all shards compute the transaction to the exact same result it is obliged to put the result in a subsequent block, as has to happen in all respective shards.
If only one shard sends a deviating result, or is missing, the transaction aborts controlled on all shards.
Again, for clarity:
Only when there is existing proof of a successful, byte-wise similar result on all involved shards and the proof beeing shared and having arrived on all relevant validators, will the finalized transaction be included in a block on all the involved shards.
In all this process there is no voting involved, as the only thing that gets exchanged between shards are tangible proofs.
This way, many shards can execute transactions un-synchronous, everybody at his time, synchonized only by a global time-out, but its still guaranteed that all participants execute exactly the same thing, with the same result, otherwise it aborts everywhere.
This solves the biggest problem of sharded networks, how to maintain atomic commitment, meaning a complex transaction, involving many states, living in many different shards, either succeeds everywhere and gets written to the ledger, or aborts everywhere, but can never succeed half or leave some stranded sub-states.
This is of course a very simplified explanation, for real understanding of the architecture of Hyperscale the protocol can be studied in great detail in the github documentations, a more poetic approach is found in hyperscale.rs.
[link to hyperscale]
[maybe link to roadmap]
-
For demonstration purposes
The full network got compiled in WASM and runs on a browser tab. The only thing simulated is the network with a 150 ms latency.
A intuitive and instructive way of understanding Hyperscale and the messaging involved.
You can run a full sharded network on the phone, send transactions and control the transactions journey until its finally commited, all messages included.
[ hyperscale demo link]
THE GOVERNMENT
In January 2026 the Radix Foundation decided to wind down and let the community decide the future of Radix.
After public discussion, mainly held in the Radix telegram group and on radixtalk, it was decided that the future of Radix should be a DAO, registered on the Marshall Islands.
To facilitate the transition a temporary Radix Accountability Council with 5 members got elected by the community in the beginning of 2026, whose task is to set up the legal framework of the future DAO and organize the hand-over from the Radix Foundation to the DAO. When the legal documents are complete, they gonna be voted for by the community before electing 7 members of the future, permanent RAC, or Radix Accountability Council.
As soon as the permanent RAC is in place the Foundation can hand over the treasury and the DAO can start its work.
This is expected to happen before the end of 2026.
Detailed description of the DAO, the legal framework, the charter and the community mechanisms can be studied in more detail on [link to daffys github]
After presenting Radix, its history, vision and progress, lets address the elephant in the room:
THE PRICE
Looking at the Radix Chart means looking at a toxic shit-coin chart that is directly understood as the chart of a failed endeavor.
The most natural reaction is to not loose time with that stuff and turn your back.
So why are we, the Radix Community, still around, fighting for the cause? Only to safe some bags that in the meanwhile became m ostly only worth some pennies? No, the situation got too dire for that, pure bag holders are long gone.
The reason is, that after having gotten used to Radix, the Wallet, the Transaction Manifest, the ease of developing complex applicati on in scrypto, the intuitivity and safety of using it, there is simply nowhere to turn to in this space.
After having gotten used to Radix, every single other chain in this space seems flawed, not suitable for daily use and as a future infrastructure of assets.
So, against all odds, we still stick around, to help push our common dream over the finishing line.
To create a public good, in the communities hand, controlled by the holders of XRD, that could very well define the future of finance, of AI powered trad ing and interacting, that is predestined to be the global infrastructure of assets, identity and owner ship.
To adress the catastrophic development of the Radix price:
What is there to be said, in hindsight…
A combination of factors, dominated by the hype, pump and dump nature of the crypto space in general, controversial token economics and selling pressure by players like whales that got their bags for free, RDX Works or the Radix Foundation led to a constant drop in price, culminating in a kind of capitulation with the passing away of our founder Dan Hughes in July 2025.
But he left a strong legacy, a resilient community that contributed to the dream, is and always w as part of it, and that decided the best way to honor what Dan created is to continue and bring it to the end.
Now, finally, the development of Hyperscale shows a clear and defined road towards a fully sharded network where the biggest obstacles have already been taken. Consensus and dynamic sharding are working and have been tested thoroughly, whats missing is integration of the Radix Engine, rewriting API connections, validator software, and preparing the upgrade itself, Xi’an.
This is a proofable claim, the codebase is public, Apache 2.0 licenced, and can be examined, compiled and replayed by anyone with interest in an advanced system of atomic consensus over a dynamically sharded enviroment.
We invite you, have a look, and judge for youself if whats being developed here is in fact the most advanced L1 protocol existing.
The day Xi’an gets live, the user won’t feel any difference. Everything just gonna behave as we are used to, the wallet, the apps, all just the same.
The genesis network will start with one shard, only when it hits its limits, it will split, depending on demand.
The real strength of Radix isn’t the fully sharded network about to come, although it is essential for worldwide adoption.
The network is already complete in its functionality, it’s live, working perfectly, doing everything as it should. Adoption can and should start now, by building, integrating, using.
Its in our hands, the community of Radix.
We don’t ask you to buy Radix.
Don´t pump the price, don’t “invest”..
Use it! Give it a try!
Get the wallet, try some of the great apps that are available. Be it standard DEFI, games, NFTs, marketplaces or developing ideas you have since long, but cannot realize in any of the other popular chains.
Try it out.
LLMs are getting better and better in creating scrypto programs, facilitated by the usage of RUST and the human readable TransactionManifest. Your own native scrypto programm and Radix application is just a few clicks away…
And decide for yourself if there is anything only slightly comparable out there.
It’s not about promises for the future. It’s about what is live, tangible, ready to use, here and now.
And if you realize the unique situation Radix is in, with its complete and uncompromising tech stack, the token price where it is, and our governance situation, maybe you want to be part as well, join the community, build, help, contribute, and become part of one of the potentially biggest disruptions in this space in the foreseeable future .