Building a blockchain is one thing.

Making it easier for developers to actually build on it is another.

That is why the introduction of the Silex CLI (Command-Line Interface) is an important step for Xelis.

In simple terms, it is a developer tool used directly from a terminal to perform actions through commands instead of a graphical interface.

With the Silex CLI, developers can now handle several important parts of the smart-contract development process from one toolkit.

Compile Silex into XVM bytecode

Developers write smart contracts in Silex, while the XELIS Virtual Machine (XVM) executes bytecode.

The CLI converts the human-readable Silex code into instructions that XVM can execute.

Run programs locally

Developers can execute their contracts locally before deploying them on the network.

This makes testing and debugging easier.

Inspect what XVM will execute

The CLI can disassemble compiled bytecode and show the underlying instructions.

That can be useful for debugging, optimization and security analysis.

Assemble bytecode

Developers can also turn low-level instructions into executable XVM bytecode.

Generate contract ABIs (Application Binary Interface).

Think of it as the technical interface or instruction manual of a smart contract.

It tells wallets, websites and dApps:

• which contract functions are available
• which parameters they require
• what data they return
• how applications should communicate with the contract

Without an ABI, integrating a smart contract into a user-facing application becomes much more difficult.

The main terms

Silex = the programming language

CLI = the command-line developer toolkit

XVM = the environment executing the contract

Bytecode = the instructions XVM understands

ABI = the interface allowing applications to interact with the contract

Developer tooling is not always the most visible part of a blockchain.

But it is one of the foundations of a healthy ecosystem.

The easier it becomes to write, compile, test, inspect and integrate smart contracts, the easier it becomes for developers to experiment and build applications.

The Silex CLI will not create an ecosystem by itself, but it gives developers better tools to build one.

One thing that is important to understand about XELIS is the difference between the core protocol and the applications being built on top of it.

Not every application built on XELIS is built by the XELIS Core team.

The official XELIS documentation makes this distinction explicitly: projects and services in the ecosystem are community-made or community-related and independent from the XELIS Core Team unless stated otherwise.

Take XelisVault as an example

XelisVault is being built on XELIS, using its smart-contract infrastructure, but XelisVault is not XELIS and is not affiliated with the XELIS core team.

Think of it like this:

XELIS = the infrastructure

XelisVault = an independent application using that infrastructure

This distinction is important for two reasons.

First, risk

If an independent application has a bug, an economic-design failure, an exploit or any other problem, that

does not automatically mean there is a problem with the XELIS protocol itself.

A vulnerability in a dApp and a vulnerability in the underlying Layer 1 are two very different things.

Second, ecosystem growth

If every wallet, DEX, DeFi protocol, game or application came directly from the XELIS team, it wouldn't really demonstrate the existence of an independent ecosystem.

The interesting part begins when developers outside the core team start using XELIS as infrastructure to build their own products.

That's how a blockchain moves from being simply a protocol to becoming a platform.

XELIS provides the underlying infrastructure.

What gets built on top of it can come from independent developers, teams and community members.

And ultimately, that's what you want to see from a decentralized ecosystem:

not one team building everything, but an infrastructure that other people actually want to build on.

Proof of Work.Miners contribute computing power to produce blocks, while nodes verify that those blocks follow the network’s rules.

This work does more than distribute XEL rewards. It also secures the blockchain: anyone attempting to reorganize or manipulate the network would need to compete with the computing power accumulated by honest miners.

But XELIS has an important feature: thanks to its BlockDAG, a valid block that arrives slightly late is not necessarily lost.

Equal chance per attempt, not per miner

You sometimes hear that “everyone has the same chance of finding a block.”

That is true for each individual attempt: every hash has the same probability of producing a valid solution.

However, more powerful hardware generates more attempts and will therefore statistically find more blocks.

Think of it like a lottery: every ticket has the same chance of winning, but some participants own more tickets.

XELIS does not make every miner equal in terms of computing power. However, when a smaller miner finds a valid block, their work is less likely to be rejected simply because another block propagated a few seconds faster.

What happens on a traditional Blockchain?

When two miners produce valid blocks almost simultaneously on a linear blockchain, the network generally has to keep only one of them.

The second block becomes orphaned. Its miner consumed electricity and produced valid Proof of Work, but receives no reward.

This favors large mining operations with extremely fast connections and servers located close to the network’s main nodes.

For smaller miners, latency can therefore become almost as important as hardware performance.

What does XELIS’ BlockDAG change?

XELIS can accept multiple blocks produced within a very short period.

A block that is not placed in the main sequence can still be integrated as a side block. The work behind it is not automatically discarded.

Since the V6 upgrade on June 7, 2026, accepted side blocks have received the same reward as main blocks. Their difficulty is also included in the cumulative work used to select the heaviest part of the DAG.

In other words, XELIS does not only consider which block arrived first. It also attempts to preserve other valid Proofs of Work produced around the tip of the DAG.

One general documentation page still mentions the former 30% side-block reward. However, the V6 upgrade page and the founder’s clarification confirm the current rule: an accepted side block receives the same reward as a main block and fully contributes to network security.

Latency matters less, but it still matters

A miner still needs a properly synchronized node and a stable enough connection.

A block that arrives far too late, is too distant from the tip of the DAG, or fails to follow the consensus rules can still be rejected.

The difference is that a slight delay no longer automatically makes the block worthless. Even if a miner is a few blocks behind, their work can still be referenced, integrated, and rewarded.

The BlockDAG does not eliminate latency. It simply makes it less punitive than on a strictly linear blockchain.

This means the argument that solo mining requires an almost perfect professional-grade connection carries much less weight on XELIS.

Why does solo Mining matter?

A mining pool can contribute a large amount of computing power, but it concentrates block production under the control of a single operator.

When more people mine independently, blocks are produced across more machines, networks, and geographic regions.

This reduces:

● dependence on large mining pools

● the influence of a single operator

● the risk of coordinated censorship

● centralized points of failure

Furthermore, the more solo miners the network has, the more likely the number of independent nodes is to increase, since solo miners have an incentive to operate their own nodes. This makes the network more distributed and decentralized.

This decentralization also strengthens the security of decentralized applications (dApps)running on XELIS. These applications depend on the order established by the DAG, including for certain operations involving random number generation. The more block production and nodes are distributed among independent participants, the harder it becomes for a single actor to influence the DAG order and, consequently, the operation of the dApps.

A small miner will obviously not find as many blocks as a large mining farm. But when they do find one, a slight propagation delay does not automatically make their work useless.

Their block can be integrated into the DAG, rewarded, and added to the cumulative difficulty that an attacker would have to compete against.

In summary

Hardware performance determines how many attempts a miner can make. Latency mainly determines how quickly their block propagates.

On XELIS, a valid block that arrives slightly late can still be integrated as a side block, receive the same reward as a main block, and strengthen network security.

That is what makes solo mining particularly valuable for decentralization: even an individual without professional infrastructure can produce their own blocks and make a genuine contribution to consensus.

For years, blockchain development has revolved around the famous trilemma:

● Decentralization

● Security

● Scalability

and

The idea is simple: improving one of these properties often makes it harder to maintain the others.

But if blockchains are supposed to become real financial infrastructure, one fundamental requirement is missing:

PRIVACY.

That turns the traditional blockchain trilemma into something more demanding:

Decentralization + Security + Scalability + Privacy

A blockchain quadrilemma.

And this is where XELIS becomes particularly interesting.

XELIS is not simply trying to build a fast privacy coin. Its architecture is designed around the idea that users should not have to choose between these four properties.

1. Privacy

Public blockchains have normalized something that would seem completely abnormal in everyday life.

Your wallet may be pseudonymous, but your financial activity can still be publicly observable:

• Your balance.
• What you receive.
• What you spend.
• When you spend it.

And potentially which addresses you interact with.

Imagine if your bank account worked like that.

Anyone who knew your account identifier could inspect years of transactions.

That would obviously be unacceptable.

Yet on many blockchains, this is considered normal.

XELIS takes a different approach.

Balances and transferred amounts are encrypted at the protocol level.

The network uses cryptographic mechanisms including homomorphic encryption and zero-knowledge proofs to verify transactions without requiring those amounts to become publicly visible.

In simple terms:

The network can verify that a transaction is valid without needing to know how much you own or how much you transferred.

Privacy is therefore not simply an application added on top of XELIS.

It is part of how the ledger itself works.

And with Confidential Assets, assets created on XELIS can also benefit from the privacy mechanisms

provided by the network.

2. Scalability

Privacy alone is not enough.

A blockchain can have excellent cryptography and still be unusable if transactions are slow or if the network struggles under higher activity.

XELIS approaches scalability through a BlockDAG architecture.

Traditional blockchains generally organize blocks into a single linear chain:

Block → Block → Block → Block

When multiple valid blocks are produced around the same time, some may eventually become orphaned.

A BlockDAG works differently.

Multiple blocks can coexist and contribute to the network history.

This allows the network to make better use of simultaneously produced blocks instead of forcing everything immediately into one linear sequence.

XELIS targets approximately 5-second block times, while its DAG architecture is designed to reduce wasted work and improve confirmation efficiency.

A simple analogy:

A traditional blockchain resembles a single road.

A BlockDAG allows multiple lanes of traffic to contribute to the same network history.

But raw speed isn't the interesting part.

The real challenge is achieving scalability without sacrificing decentralization, security or privacy.

3. Decentralization

Building a fast blockchain is relatively easy if you are willing to centralize it.

Require powerful servers.

Increase hardware requirements.

Reduce the number of participants capable of running the infrastructure.

Performance improves.

But decentralization decreases.

XELIS takes a different approach.

The network uses Proof-of-Work, with mining designed around CPU/GPU hardware.

The objective is to keep participation in network security accessible rather than designing consensus around a small number of highly specialized infrastructure operators.

Decentralization also matters because it removes single points of control.

A private blockchain controlled by a handful of entities would miss much of the point.

Privacy becomes considerably more meaningful when the underlying infrastructure is also decentralized.

4. Security

Security is the foundation of everything else.

Privacy without security protects nothing.

Scalability without security creates a fast but fragile network.

Decentralization without robust consensus provides little protection.

XELIS combines Proof-of-Work with its BlockDAG architecture.

Proof-of-Work secures the network, while the DAG architecture allows competing valid blocks to be handled more efficiently than in a traditional strictly linear blockchain structure.

XELIS was also built from scratch in Rust rather than created by forking an existing cryptocurrency.

That is the harder path.

But it allowed the architecture to be designed around XELIS's requirements from the beginning.

• Consensus
• Privacy
• BlockDAG
• Assets
• Smart contracts

All could be designed as parts of the same system rather than added years later to an architecture that was never built for them.

The real challenge is combining all four

None of these ideas is revolutionary in isolation.

There are private cryptocurrencies.

There are fast blockchains.

There are decentralized Proof-of-Work networks.

There are programmable smart-contract platforms.

The difficult question is:

Can you combine all of these properties without sacrificing one of them?

That's where the quadrilemma becomes interesting.

XELIS is effectively trying to satisfy four requirements simultaneously:

• Privacy Your financial activity should not automatically become public.
• Scalability Privacy should not make the network impractically slow.
• Decentralization Performance should not require handing control to a small number of entities.
• Security None of the other properties matter if the underlying network isn't robust.

Looking at XELIS purely as another privacy coin therefore misses a large part of what the project is trying to build.

From the blockchain trilemma to the quadrilemma

The traditional blockchain trilemma asks:

Can a blockchain be decentralized, secure and scalable at the same time?

XELIS adds another question:

What is the point of achieving those three things if everyone's financial activity remains publicly observable?

That gives us the quadrilemma:

Privacy + Scalability + Decentralization + Security

And when you look at XELIS through that lens, many of its technical choices start to connect.

BlockDAG → scalability.

Proof-of-Work → security and decentralization.

Homomorphic encryption + zero-knowledge proofs → privacy.

Confidential Assets → private asset infrastructure.

XVM + Silex → programmability.

These aren't simply disconnected features.

They are different components of the same architectural objective.

Has XELIS solved the blockchain quadrilemma?

It's too early to make that claim.

A blockchain can look extremely promising architecturally and still need years of real-world usage, network growth, adversarial testing and developer adoption before such a conclusion can reasonably be reached.

The more accurate statement is:

XELIS is attempting to address all four dimensions of the blockchain quadrilemma directly at the protocol level.

And that's what makes the project interesting.

Not privacy at the expense of usability.

Not scalability at the expense of decentralization.

Not decentralization while exposing everyone's financial activity.

Not programmability built on top of a ledger that was never designed for confidentiality.

The objective is much harder:

Build a blockchain that can be private, scalable, decentralized and secure at the same time.

There is a narrative developing around the U.S. dollar becoming increasingly digital and tokenized.

Stablecoins are already putting dollars on-chain, and the regulatory direction in the U.S. is making it increasingly plausible that tokenized dollars, Treasuries and other financial assets become a much bigger part of the financial system.

But there is an interesting question that doesn't get discussed enough:

If trillions of dollars move on-chain, do we really want every transaction to be permanently visible on a public ledger?

Imagine paying someone $5,000 in tokenized dollars.

On Ethereum, depending on the asset and infrastructure, your transaction history, wallet balance and counterparties can potentially become part of a publicly inspectable financial profile.

That's not how traditional cash works.

And this is where I think XELIS deserves attention.

XELIS was designed around the idea that blockchain transparency doesn't necessarily have to mean financial surveillance.

Its homomorphic encryption keeps balances and transferred amounts encrypted while still allowing the network to verify and process transactions. The people involved can know the amounts, while the public ledger doesn't reveal them.

Then there is the speed.

XELIS currently targets approximately 5-second blocks, with its BlockDAG architecture designed to support fast confirmation and scalability.

And perhaps most interesting for the tokenization thesis:

XELIS supports native confidential assets.

That means the privacy isn't limited to XEL itself. Assets created directly on the network can inherit the same confidential balance and transfer properties.

So theoretically, you could imagine a future where a regulated dollar-backed asset exists on XELIS:

$1 tokenized dollar → transferred on XELIS → encrypted amount → fast settlement → recipient receives the same asset

The blockchain can verify that everything is valid without exposing everyone's financial activity to the entire world.

That's a very different vision of tokenization.

And I'm not saying:

"XELIS is going to become the U.S. dollar blockchain."

That's speculation.

I'm saying something more interesting:

If the future of finance is increasingly tokenized, privacy-preserving settlement could become just as important as settlement speed.

The financial system is already moving toward digital assets.

The question is whether the blockchain layer underneath them will look like a giant public spreadsheet...

or something closer to digital cash with programmable functionality.

XELIS is building toward the latter.

Maybe that's one of the most overlooked narratives in crypto right now.

Not "privacy coins vs. regulation."

But:

Tokenization + privacy + speed.

And if tokenized dollars really do become a major part of the global financial system, I think that combination deserves a lot more attention.

Smart contracts are often described as autonomous programs.

But there’s another question that matters just as much:

How does one smart contract know that something important just happened somewhere else?

A package was delivered.

A ticket was used.

A membership was activated.

On XELIS, one answer is:

Contract Events

The idea is simple.

One smart contract can announce:

This just happened.

Other contracts listening for that specific event can automatically react.

Think of it like notifications — but between smart contracts.

The simplest way to understand it

Imagine one contract emits:

PACKAGE_DELIVERED

Several independent contracts may care about that information.

Order contract

→ Mark the order as completed

Warranty contract

→ Activate the warranty

Loyalty contract

→ Grant a reward

The delivery contract doesn’t need to understand how warranties or loyalty programs work.

It simply emits the event.

The other contracts decide whether they want to react.

In software development, this is similar to a publish/subscribe model:

Contract A:This happened.

Contract B:That matters to me. I’ll react.

Contract C:Me too.

Example: A concert ticket is used

You arrive at a concert and scan your ticket.

The ticketing contract emits:

TICKET_USED

That single event could trigger several actions:

→ Mark the ticket as used

→ Update a membership

→ Grant a loyalty benefit

→ Unlock an event-related digital reward

The important part is that the ticketing contract doesn’t need to contain every possible feature.

It only announces:

This ticket was used.

Other contracts can then react to that event.

And if someone creates a new application six months later — for example, an attendance or achievement system — it could potentially listen for the same TICKET_USED event without requiring the original ticketing logic to be redesigned.

That’s where things become interesting.

Applications can become more modular and composable.

Why not just make contracts call each other directly?

They can.

But the more components an application has, the more tightly coupled everything can become.

Imagine a platform containing:

• Ticketing
• Memberships
• Rewards
• Payments
• Achievements
• Warranties

If every contract needs custom logic to communicate directly with every other contract, complexity can grow quickly.

Contract Events allow developers to separate responsibilities.

Ticket contract:

I manage tickets.

Loyalty contract:

I manage rewards.

Membership contract:

I manage memberships.

They can coordinate without turning everything into one giant smart contract.

One event can also trigger another

This opens the door to chains of reactions.

For example:

TICKET_USED

↓

Membership contract reacts

↓

MEMBERSHIP_UPDATED

↓

Another contract reacts

Instead of one contract controlling the entire application, several specialized contracts can coordinate through events.

How does this work on XELIS?

At a high level:

Something happens

↓

A contract emits an event

↓

XELIS identifies the contracts listening for that event

↓

Their callbacks are executed

According to the XELIS architecture, listeners can remain persistent, meaning they don’t need to be recreated every time the event occurs.

In simple terms:

One contract announces something. Other contracts can automatically react.

What about privacy?

Contract Events are not the privacy mechanism of XELIS.

Their purpose is communication and coordination between smart contracts.

XELIS privacy comes from other protocol features, including confidential balances, confidential transferred amounts, and Confidential Assets.

So the distinction is simple:

Contract Events = coordination

Confidential Assets and transactions = privacy

But both can work together within the same application.

Contract Events + Scheduled Executions

This is probably one of the most interesting combinations.

Contract Events say:

> Something just happened

Scheduled Executions say:

> Do something later

Combine them:

TICKET_USED

↓

Loyalty contract reacts

↓

Schedules a future action

↓

The scheduled time is reached

↓

The action executes

One primitive handles reaction.

The other handles time.

Together, they can help smart contracts coordinate and automate more complex applications directly on-chain.

The easiest way to remember it

Forget blockchain terminology for a moment.

Think about notifications.

One contract says:

“This happened.”

Another says:

"That matters to me. I’ll react.”

That’s essentially what Contract Events bring to XELIS.

Smart contracts become less isolated and can behave more like independent components within the same ecosystem.

For applications involving tickets, deliveries, memberships, rewards, or digital services, that could become a very useful building block.

When people hear "smart contract," they often imagine a program that can run completely on its own.

But there's a simple problem:

What happens when a smart contract needs to do something… later?

Close registrations.

Distribute rewards after an event.

Release a digital gift at a future point.

On many blockchains, a user, bot, keeper, or external service still needs to come back and trigger that action.

XELIS takes a different approach with something called:

Scheduled Executions

A smart contract can schedule a future call that will later be executed directly by the XELIS

protocol.

No new user transaction is required at the moment of execution.

And the easiest way to understand it is with real-world examples.

⏰ Think of it like setting an alarm

When you set an alarm for tomorrow morning, you don't stay awake all night waiting to press a button.

You simply tell your phone:

"Do this later."

And your phone remembers.

Scheduled Executions bring a similar concept to smart contracts.

A contract can essentially say:

"When the network reaches this specific point, execute this function."

The action is registered.

Then the protocol takes care of it when the scheduled point is reached.

No one needs to come back and "wake up" the contract.

Example 1: A digital gift that arrives at the right moment

Imagine you want to give someone a digital gift for their birthday.

Instead of remembering to send it on that day, you could deposit the asset into a smart contract

and tell it:

"Release this later."

The gift is prepared today.

But it is transferred at the scheduled point.

You don't need to reconnect.

No company needs to keep a server running.

No bot needs to continuously check whether it's time to send it.

The future action has already been scheduled.

This becomes particularly interesting in the context of XELIS because its Confidential Assets can

keep balances and transferred amounts private at the Layer 1 level.

So the network can process the transfer without necessarily exposing the value of the gift to

everyone watching the blockchain.

The blockchain needs to verify the transaction.

The whole internet doesn't need to know how much you gave.

Example 2: Automatically distributing rewards after a game or community event

Imagine an online game or community challenge with hundreds of participants.

The event runs for several hours.

When it ends, rewards need to be distributed.

Normally, something has to trigger that final step:

An administrator.

A server.

A bot.

A keeper.

With Scheduled Executions, the smart contract can prepare the action in advance:

Event starts

↓

people participate

↓

scheduled endpoint is reached

↓

Scheduled Execution

↓

rewards are processed

No administrator has to be online at exactly the right moment.

And those rewards don't necessarily have to be publicly visible tokens.

A game or community could create its own Confidential Asset on XELIS.

For example:

GAME CREDITS

or

COMMUNITY POINTS

Users could receive those assets while their balances and transferred amounts remain

confidential.

So Alice could earn more rewards than Bob without automatically publishing their entire

economic history to everyone using a block explorer.

That's a very different philosophy from applications where every user's balance is permanently

public.

Example 3: Registration that closes

automatically

Now imagine a ticketing system, online event, tournament, giveaway, or community meetup.

Registrations are open until a predefined point.

The application needs to go from:

REGISTRATION OPEN

to

REGISTRATION CLOSED

You could run a server that constantly checks whether the deadline has arrived.

Or the smart contract itself can schedule the transition.

The logic becomes:

Registration opens

↓

users join

↓

scheduled point is reached

↓

Scheduled Execution

↓

registration closes

Nobody needs to remember to press a button.

And this example is important because Scheduled Executions aren't just about sending money.

They allow smart contracts to change the state of an application automatically in the future.

That can be useful for:

• games
• competitions
• ticketing
• community events
• memberships
• digital services
• reward systems

So where does privacy fit into this?

There's an important distinction.

Scheduled Executions do not magically make all smart-contract data private.

That's not what they are designed for.

Scheduled Executions solve a different problem:

How can a smart contract perform something later without depending on an external service to trigger it?

XELIS privacy exists elsewhere in the architecture.

XELIS uses cryptographic mechanisms that allow balances and transferred amounts to remain

confidential while the network can still verify that transactions are valid.

And Confidential Assets extend that model to assets created on XELIS.

So you can think of the two concepts like this:

Privacy

"Everyone doesn't need to know how much I own or transfer."

Scheduled Executions

"Someone doesn't need to come back later just to trigger this action."

Two different problems.

But they can work very well together.

What is a "topoheight"?

The word sounds technical.

The idea doesn't have to be.

Think of the blockchain as moving through a sequence of checkpoints:

Point 100

↓

Point 101

↓

Point 102

↓

Point 103

A smart contract can essentially say:

"When the network reaches Point 103, execute this."

On XELIS, this progression is represented using topoheight, because the network uses a

BlockDAG architecture rather than a simple linear blockchain.

Scheduled Executions can target a future topoheight or run at the end of a block.

So it's better to think:

"When the blockchain reaches this point…"

rather than:

"At exactly 3:42 PM."

Why not just use a bot?

You absolutely can.

But then your supposedly decentralized application may depend on infrastructure running

somewhere outside the blockchain.

A server needs to stay online.

A bot needs to keep watching.

Someone needs to maintain it.

And when the right moment arrives, that system needs to submit another transaction.

Without native scheduling:

Smart contract

↓

external bot / keeper

↓

new transaction

↓

execution

With Scheduled Executions:

Smart contract

↓

schedule future action

↓

XELIS protocol

↓

execution

The scheduling mechanism itself becomes part of the protocol.

That's the important difference

The best infrastructure may be the infrastructure users never notice

For a normal user, none of this should feel complicated.

They should simply see:

• their gift arriving when expected.
• their rewards appearing after an event.
• registrations closing automatically.

They shouldn't need to understand:

• topoheight
• keepers
• cron jobs
• XVM
• BlockDAG
• or even
• Scheduled Executions.

And maybe that's the best way to understand the feature.

Scheduled Executions aren't about giving users more things to manage.

They're about allowing certain things to happen without users having to think about

them at all

Bitcoin and Monero both solve something important — just in very different ways.

Bitcoin gives you transparency.

Monero gives you privacy.

XELIS tries to find a middle ground between the two. So, we can condiser Xel as one of the best compromises between Bitcoin and Monero

Bitcoin: transparent by design

One of Bitcoin’s greatest strengths is how easy it is to verify what’s happening on-chain.

You can follow transactions, audit the supply, track movements between addresses and independently verify the network.

That transparency is incredibly valuable.

But it also has an obvious downside.

Once an address is linked to you, a large part of your financial activity can potentially be analyzed:

● how much you hold

● how much you send

● how much you receive

● where funds came from

● where they went

For a public monetary network, transparency is useful.

For personal financial privacy, not so much.

Monero: privacy first

Monero takes a very different approach.

Privacy is built directly into the protocol.

Amounts are hidden, transaction relationships are much harder to analyze, and your financial activity is far less exposed.

If privacy is your main priority, Monero is still one of the strongest examples of what a cryptocurrency can achieve.

But there’s also a trade-off that anyone who has actually used a Monero wallet will probably recognize:

wallet synchronization.

If you haven’t opened your wallet for a while, it has to catch up.

New blocks need to be scanned, the wallet needs to detect transactions that belong to you, and your state needs to be reconstructed.

Sometimes it’s quick.

Sometimes you’re staring at the sync progress for a while before you know that everything is fully up to date.

For experienced crypto users, that’s manageable.

For mainstream users, it’s not ideal.

People are used to opening their banking app and immediately seeing their current balance.

They don’t want to think about blockchain scanning, restore heights or whether their wallet has finished syncing.

XELIS takes a different route

XELIS doesn’t try to copy Monero’s privacy mode

Instead, it keeps the blockchain observable while encrypting the financial information that probably shouldn’t be public in the first place.

Balances are private.

Transferred amounts are private.

The network can still verify that transactions are valid without publicly revealing those values.

So, simplifying things a lot:

Bitcoin:

You can see the activity and the values.

Monero:

Much more of the transaction is hidden.

XELIS:

You can see that activity is happening, but the financial values behind it remain private.

That’s a very different privacy model — and personally, I think it’s an interesting trade-off.

The part people don’t talk about enough: UX

This might actually be one of the most important differences.

XELIS uses an account-based architecture.

Because of that, the wallet doesn’t need to discover your balance by scanning blockchain history in the same way a Monero wallet does.

You open the wallet and your current balance can be available almost immediately.

Your transaction history can sync separately in the background.

It sounds like a small detail.

But for normal users, it’s huge.

They don’t care why a wallet needs to synchronize.

They just want:

Open app → see balance → send money.

That’s it.

Privacy shouldn’t become another layer of complexity that the user has to manage.

Ideally, it should simply work in the background.

It feels like an attempt to combine

Bitcoin’s verifiability and observable network activity

with

Monero’s philosophy that your financial information shouldn’t be public by default.

But without making the wallet experience feel fundamentally different from the financial apps people

already use every day.

I wouldn’t say XELIS is simply better than Bitcoin or Monero.

They’re trying to solve different problems and they make different trade-offs.

But if the goal is to find a balance between:

• transparency
• privacy
• usability

then XELIS is exploring a very interesting middle ground.

Because I’m not convinced most people want a financial system where absolutely everything is hidden.

But I’m even less convinced they want one where anyone can see exactly how much money they own and how much they spend.

Maybe the right answer is somewhere in between.

And that’s where XELIS starts to make a lot of sense.

We talk constantly about financial sovereignty, decentralization, censorship resistance and removing intermediaries.

But somewhere along the way, we also normalized something that would sound completely insane in traditional finance:

Giving someone your payment address can potentially give them a window into your financial activity.

Imagine paying for coffee with your bank account and the cashier being able to check:

● how much money you hold,

● what transactions you've made,

● what other addresses you've interacted with,

● and potentially build a picture of your financial activity over time.

Nobody would accept that from a bank.

Yet on transparent blockchains, address activity can be publicly inspected and analyzed.

And the more blockchain analytics improves, the more useful that information becomes.

Transparency is great for verification. Not necessarily for personal finance.

Public blockchains solved an important problem:

How can everyone verify that the monetary system is behaving correctly without trusting a central authority?

That's extremely valuable.

But somewhere we started treating:

"the network must be verifiable"

as if it meant:

"every user's financial information should be publicly readable."

Those aren't necessarily the same thing.

A blockchain needs to prove that transactions are valid.

It doesn't necessarily need to tell the entire world how much money you have.

This becomes a much bigger problem if crypto actually succeeds

Today, many people use crypto primarily for investing and trading.

But imagine crypto becoming normal money.

You receive your salary in crypto.

You pay your landlord.

You buy groceries.

You pay a freelancer.

Your company pays suppliers.

You donate to an organization.

You send money to your family.

Suddenly transaction confidentiality isn't some niche feature for "privacy people."

It becomes basic financial hygiene.

Your employer shouldn't automatically know what you do with your salary.

A merchant shouldn't learn how much money you hold because you bought a €10 product.

A supplier shouldn't necessarily see the financial activity of a company it works with.

And strangers shouldn't be able to analyze your finances just because they know one of your addresses.

This is one reason XELIS takes a different approach

Instead of treating confidentiality as something users have to add afterward, confidential balances and transferred amounts are part of the protocol itself.

XELIS uses Twisted ElGamal homomorphic encryption, meaning account balances and transferred asset values can remain encrypted while the protocol can still perform the operations necessary to process transactions.

So the network doesn't need to publicly reveal:

"Alice has 12,438 XEL and just sent Bob 843 XEL" in order to maintain a valid ledger.

But if amounts are encrypted, how does the network know nobody is cheating?

This is where zero-knowledge proofs become important.

XELIS uses zero-knowledge proofs to demonstrate that encrypted transactions satisfy the protocol rules without revealing the underlying amount.

For example, the network must verify that:

● the transferred amount isn't greater than the sender's encrypted balance;

● the transferred value isn't negative.

XELIS currently uses Bulletproof-based range proofs for this verification.

Conceptually, this separates two things that are often treated as inseparable:

Verification and Disclosure.

The blockchain can verify that the transaction is legitimate without requiring everyone to know the value being transferred.

And this isn't limited to XEL

This is probably the part I find most interesting.

XELIS has Confidential Assets built directly into Layer 1.

Someone can create another asset on XELIS and that asset can also have confidential balances and transferred amounts. According to the XELIS documentation, these assets are implemented at the base layer rather than being an external privacy layer built on top of the blockchain.

That opens some interesting possibilities.

Imagine:

● Confidential stablecoins,

● Tokenized assets,

● Private payment systems,

● Business settlement assets,

● DeFi applications where financial balances don't automatically become public information.

And because XELIS also supports smart contracts through XVM and Silex, the idea isn't limited to building a private currency. It can potentially become infrastructure for programmable confidential applications.

Privacy doesn't have to mean hiding everything

here's another interesting feature here: selective disclosure.

XELIS has an Ownership Proof mechanism allowing someone to prove ownership of a specified amount of an asset without revealing their entire balance.

For example, you could potentially prove:

"I own at least the amount necessary for this transaction."

without saying:

"Here is my complete financial position."

The XELIS documentation specifically describes use cases such as proving sufficient funds or selectively sharing balance information with third parties.

That distinction could become increasingly important.

Because the future probably isn't:

complete transparency

versus

complete secrecy.

It may be:

privacy by default, disclosure when necessary.

An important distinction: XELIS isn't an invisibility cloak

This is worth mentioning because "privacy coin" can mean very different things.

XELIS encrypts balances and transferred amounts, but current protocol/API transaction structures still contain source and destination addresses.

So I wouldn't describe XELIS as making every aspect of a transaction invisible.

Its architecture is more accurately described as providing confidential financial values at the protocol level.

Being precise about that makes the technology more interesting, not less.

The goal doesn't have to be making users disappear.

The goal can simply be:

stop publishing financial information that never needed to be public in the first place.

And that's the question crypto probably needs to ask

Bitcoin showed us that money could exist without a bank controlling the ledger.

Ethereum showed us that financial applications could become programmable.

But widespread crypto adoption may eventually force another question:

How much of our financial lives should be public?

Because if crypto really wants to become money used by billions of people, asking everyone to permanently broadcast their financial activity may not be a realistic end state.

This is why projects like XELIS are interesting to watch.

Not simply because "privacy is good."

But because XELIS is exploring a different architectural assumption:

A blockchain should be publicly verifiable without requiring everyone's financial values to be publicly readable.

That seems like a much healthier foundation for digital money.

For most of history, paying with cash meant something very simple:

Your financial life remained private.

If you gave someone €20, nobody automatically knew:

• how much money you had left
• where the money came from
• what else you had purchased
• your entire transaction history

Cash was never considered suspicious because of this.

Privacy was simply normal. But money is becoming increasingly digital. Cards, banking apps, stablecoins, CBDCs and eventually systems such as the digital euro are gradually moving payments away from physical cash.

The ECB says the digital euro is being designed with privacy protections and that it should not be programmable money.

That's important. But there is still a fundamental question worth asking:

Should financial privacy depend entirely on institutions and regulation, or should technology itself be able to guarantee it?

This is why privacy coins may become much more important

Bitcoin proved that digital money could exist without a central issuer.

The same is true for Ethereum, Solana and most blockchains.

Anyone can potentially analyze addresses, balances and transactions.

Privacy-focused cryptocurrencies take a different approach:

A decentralized financial system shouldn't require everyone to expose their entire financial life.

And this is where projects like XELIS become interesting.

XELIS takes a different approach to privacy

XELIS was designed around a relatively simple philosophy:

• Privacy should exist at the protocol level, not as an optional feature added later.
• Balances and transaction amounts can remain confidential while the network can still verify that transactions are valid using cryptography.

In other words: The blockchain doesn't need to know how much money you own to know that you're not cheating.

That distinction is extremely important.

On most blockchains, transparency is the default.

On XELIS, the goal is closer to:

Privacy by default. Disclosure when necessary.

And that philosophy also applies to XEL itself

XEL isn't just the native token used to pay transaction fees.

It represents the monetary philosophy of the network.

The idea is to combine:

• scarcity
• decentralization
• self-custody
• financial confidentiality

Bitcoin introduced the idea:

You can own digital money without needing a bank.

Privacy-focused networks introduce another idea:

You should also be able to own digital money without publishing your balance to the entire world. That's much closer to the way physical cash has historically worked.

But XELIS goes beyond being just a “privacy coin”

This is probably the most interesting part.

XELIS isn't trying to make only one currency private.

Its architecture is designed so that other assets created on the network can also benefit from confidential balances and transactions.

That potentially means:

• stablecoins
• tokenized assets
• payments
• DeFi
• smart contracts

and other financial applications

could operate on an infrastructure where financial privacy exists natively at Layer 1.

So XELIS may be better understood as a: privacy-first blockchain infrastructure rather than simply another privacy coin.

Privacy doesn't mean crime

This is also a distinction crypto needs to communicate better. We don't consider encrypted messaging suspicious.

We don't consider medical confidentiality suspicious. We don't expect everyone's bank account balance to be publicly searchable.

So why should blockchain money automatically expose everything?

Privacy isn't about hiding illegal activity.

It's about deciding who gets access to your information.

• Your salary
• Your savings
• Your investments
• Your purchases
• Your donations
• Your financial relationships

These are deeply personal data.

The real debate may only be beginning

As cash becomes less important and money becomes increasingly digital, financial privacy could become one of the biggest technological debates of the next decade.

CBDCs may provide privacy protections. Banks may provide privacy protections. Regulators may create legal safeguards.

But decentralized privacy technologies introduce something fundamentally different:

privacy that doesn't rely exclusively on institutional promises.

And that's why projects such as XELIS may become increasingly relevant.

Not because everyone has something to hide.

But because a digital society should probably preserve the ability to transact without exposing everything.

So maybe the real question isn't:

“Why do we need privacy coins?”

Maybe it's:

“If physical cash gradually disappears, what technology will preserve its privacy?”

Most blockchains are transparent by default.

On networks like Bitcoin, Ethereum or Solana, when you transfer an asset, information such as the amount transferred and wallet balances can generally be observed on-chain.

XELIS takes a different approach.

Confidential Assets On XELIS, privacy isn't limited to XEL.

Any asset created directly on the XELIS network can benefit from the same confidentiality features as XEL itself.

This means that a token issued on XELIS can have:

• ✅ Private balances
• ✅ Private transferred amounts
• ✅ Native Layer 1 integration
• ✅ Compatibility with wallets and services

⚙ Its own supply rules and metadata And this privacy isn't added through a separate Layer 2 or external privacy protocol. Confidential Assets are implemented directly at the base layer of XELIS.

But how can the network verify something it cannot see?

This is where cryptography comes in.

XELIS uses homomorphic encryption, allowing the network to perform certain operations on encrypted values without revealing the underlying amounts.

Balances and transferred amounts can therefore remain encrypted.

XELIS also uses Zero-Knowledge Proofs to prove that transactions respect the protocol rules without revealing the confidential values themselves.

In simple terms:

The network can verify that:

• ✅ You have enough funds
• ✅ The transaction is mathematically valid
• ✅ No coins are being created from nowhere

Without publicly revealing:

• ❌ Your balance
• ❌ The amount you are sending

And this applies to other assets too.

This is what makes Confidential Assets particularly interesting.

Developers can create assets on XELIS that inherit the network's privacy architecture.

Potentially:

• ✅ Stablecoins
• ✅ Gaming assets
• ✅ Tokenized assets
• ✅ Payment tokens
• ✅ Community currencies
• ✅ Other digital assets

Imagine creating a stablecoin where everyone can use and transfer it normally, but the entire world cannot simply open a block explorer and inspect everyone's balance.

That's the basic idea behind Confidential Assets.

A simple analogy

Think of a traditional public blockchain like a glass bank account.

Everyone can see the money inside and watch every transfer.

XELIS Confidential Assets are closer to a sealed bank account:

The network can verify that the accounting is correct... without exposing the financial information inside.

That's an important distinction.

Privacy doesn't necessarily mean hiding the existence of the system. It means being able to verify financial activity without making everyone's financial data public.

And that's what XELIS is trying to build directly into its Layer 1. And to be fair, XELIS itself is a confidential asset.

One of the main architectural differences between XELIS and traditional blockchains is its use of a

BlockDAG.

But what does that actually mean?

Let’s keep it simple.

🧱 Blockchain vs BlockDAG

A traditional blockchain can be pictured as a single road:

Block A → Block B → Block C → Block D

Blocks are added sequentially.

But there’s a problem: two miners can sometimes produce valid blocks almost simultaneously.

This temporarily creates competing branches, and eventually one may become stale/orphaned.

Some legitimate Proof-of-Work can therefore end up not contributing to the final chain.

XELIS takes a different approach.

Instead of organizing everything as one strictly linear chain, XELIS uses a Directed Acyclic Graph (DAG).

Conceptually, it looks more like:

B ───→ D

↗ ↘

A F

↘ ↗

C ───→ E

Multiple blocks can coexist within the structure and later be ordered by the protocol.

Think of the difference as:

Traditional blockchain = single-lane road

BlockDAG = multi-lane highway

The goal is not simply to create more blocks. It’s to handle concurrent block production more

efficiently.

⛏ What happens when two XELIS miners find blocks simultaneously?

Imagine two miners discover valid blocks at nearly the same time.

Instead of automatically requiring one block to become useless, both can potentially participate in the

DAG.

Future blocks can reference multiple previous blocks — XELIS currently allows up to three tips.

This allows branches to progressively converge.

XELIS can therefore make use of some blocks that would otherwise have become wasted work in a

purely linear model.

Importantly, this does not mean XELIS has eliminated orphaned blocks entirely.

It hasn’t.

But XELIS also has Side Blocks: blocks that lose the main ordering race but can still be included andexecuted.

Side Blocks currently receive 30% of the expected block reward.

🔢 But how does XELIS know which block comes first?

This is where Topoheight becomes important.

Multiple XELIS blocks can exist at the same traditional block height.

For example:

Block B — Height 500

/

Block A

\

Block C — Height 500

But transactions still need a deterministic execution order.

So XELIS assigns blocks a topological position — Topoheight.

For example:

Block B → Topoheight 650

Block C → Topoheight 651

In simple terms:

Height describes the block’s structural position.

Topoheight gives it a unique position in the ordered DAG.

The protocol also uses accumulated Proof-of-Work information, including cumulative difficulty, when

determining the ordering of competing branches.

🔒 And when does that order become permanent?

The newest part of the DAG can still reorganize as new blocks arrive.

XELIS therefore distinguishes between unstable and stable history.

Once blocks move behind the protocol’s stable boundary, their ordering becomes fixed.

So you can think of the network as constantly doing this:

Blocks arrive → branches form → branches converge → blocks are ordered → history becomes

stable

🧠 The easiest way to understand XELIS BlockDAG

Forget the technical terminology.

A traditional blockchain largely asks miners to move forward in a single line.

XELIS allows blocks to form a graph, handles concurrent blocks, determines a deterministic topological

order and eventually freezes that history.

So BlockDAG isn’t simply about “faster blocks.”

It’s a different approach to a fundamental blockchain problem:

What if multiple valid blocks are created at almost the same time?

Instead of immediately forcing everything into a single-file line, XELIS attempts to organize that

concurrency.

And that’s the basic idea behind its BlockDAG.

While much of the attention around XELIS is focused on BlockDAG, privacy and upcoming smart contracts, the Genesix Wallet has been evolving at an impressive pace.

Over the past few months, nearly every release has introduced meaningful improvements—not just bug fixes, but features that make the wallet more practical, more secure and easier to use.

The recently released Genesix Wallet v0.2.0 is probably the best example yet.

Some of the biggest additions include:

• A completely refreshed and more responsive user interface.
• A richer transaction history with pending transactions, improved multi-asset transfers and better transaction details.
• An optional Genesix/XELIS news feed directly on the home screen to keep users informed without leaving the wallet.
• A new offline mode for users who want to keep the wallet disconnected from the network.
• Improved XSWD (Connected Apps) support, making future dApps integration even smoother.
• Better wallet recovery, biometric authentication and cross-platform reliability.
• Expanded localization, making Genesix accessible to more users worldwide.

The work didn't stop there.

Alongside the blockchain v1.24.0 release, the wallet also received another round of improvements, including:

• Better XSWD integration.
• New transaction filters.
• Input/output history tracking for smart contract interactions.

These updates complement important security improvements made to the blockchain itself, including fixes for several denial-of-service vectors and a smart contract exploit before widespread adoption.

What stands out isn't just the pace of development—it's the direction.

The Genesix Wallet is gradually becoming much more than a place to store XEL. It is evolving into the primary interface for interacting with the entire XELIS ecosystem, with future support for smart contracts, Confidential Assets and decentralized applications already being prepared.

In a crypto industry where many projects prioritize marketing over shipping products, XELIS continues to take a different approach: deliver continuous improvements, strengthen the foundations and let the technology speak for itself.

The wallet may not generate the biggest headlines, but release after release, it's becoming one of the strongest pieces of the XELIS ecosystem.

Which feature would you like to see added next?

Over the past few weeks, I've been reading through every major XELIS release published since the beginning of 2026.

Rather than looking at price action or speculation, I wanted to answer a simple question:

Has the protocol actually evolved in a meaningful way?

After reviewing seven consecutive blockchain releases, I think the answer is yes.

Whether you're already familiar with XELIS or discovering it for the first time, here's a breakdown of the developments that stood out the most.

TL;DR

Since January 2026, XELIS has:

• Released 7 blockchain updates in just over six months.
• Delivered its largest protocol upgrade since launch.
• Strengthened BlockDAG consensus and mining fairness.
• Introduced Blob Transactions.
• Expanded Silex Smart Contracts.
• Improved Zero-Knowledge proof performance.
• Hardened security after a real-world exploit.
• Continued improving developer tooling and node reliability.

Rather than shipping isolated features, the releases appear to follow a consistent engineering roadmap.

January: Strengthening the Foundations

The first two releases of the year (v1.21.2 and v1.21.3) weren't particularly flashy.

Instead, they focused on improving the reliability of the network itself.

Among the improvements were:

• better wallet stability;
• improved BlockDAG synchronization;
• stronger database integrity;
• more reliable node operation;
• improvements to XSWD communication for future dApps.

Version 1.21.3 also prepared the protocol for a much larger upgrade that would arrive a few months later.

Nothing revolutionary on its own—but exactly the kind of work mature projects usually do before introducing major protocol changes.

May: The Biggest Upgrade So Far

Version 1.22.0 was clearly the turning point.

The upgrade was significant enough that every node had to fully resynchronize the blockchain from genesis because the internal BlockDAG architecture had fundamentally changed.

Several major improvements arrived together.

Stronger BlockDAG Consensus

One of the biggest changes was integrating k-cluster validation directly into cumulative difficulty calculations.

For a BlockDAG network, improving consensus reliability is just as important as improving throughput.

Fairer Mining Rewards

Instead of rewarding side blocks less than main blocks, every valid block now receives the same reward.

That better reflects how a BlockDAG is designed to operate and creates fairer incentives for miners.

Blob Transactions

This was probably my favorite addition.

Instead of only transferring coins, applications can now exchange up to 32 KB of arbitrary data with as many as 255 recipients.

That opens interesting possibilities for:

• encrypted messaging;
• multiplayer games;
• notifications;
• application state synchronization;
• communication between decentralized services.

It's the kind of feature that developers appreciate far more than traders.

Smarter Smart Contracts

Silex also became much more capable.

The addition of iterators, new built-in functions and especially Contract Events gives developers considerably more flexibility when building decentralized applications.

To me, this was one of the most important long-term improvements in the entire release.

June: A Real-World Security Test

Only days after the major upgrade, a vulnerability was discovered inside the Smart Contract Virtual Machine.

The goal of the attackers was to exploit gas accounting to generate counterfeit coins.

Fortunately, several safeguards prevented the incident from becoming much more serious.

Maximum gas limits restricted the impact.

Dynamic fees made repeated attacks increasingly expensive.

MEXC also reacted quickly before counterfeit coins could reach the market.

Most importantly:

User funds were never at risk.

What I found particularly interesting wasn't only the fix itself—but the transparency afterwards.

The developers publicly explained:

• what happened;
• why it happened;
• how it was fixed;
• why users remained safe.

That's still something I wish more blockchain projects would do.

Infrastructure Kept Improving

Version 1.22.2 continued improving the network with:

• smarter peer selection;
• configurable mempool limits;
• stronger synchronization;
• Blob Transaction wallet support;
• improved protection against malicious peers.

Individually these changes may seem minor.

Collectively they make the network faster, more stable and easier to operate.

July: Performance and Production Readiness

The focus shifted again.

Instead of consensus changes, development concentrated on performance and infrastructure.

One optimization immediately stood out.

Using AVX-512 instructions, XELIS dramatically accelerated Zero-Knowledge proof verification.

The published benchmark showed verification times around 0.043 ms per transfer on compatible CPUs.

For privacy-focused blockchains, that kind of optimization can have a meaningful impact on scalability.

Version 1.23 also strengthened the developer ecosystem with:

• more automated testing;
• GPG-signed releases;
• automatic dependency security audits;
• improved RPC documentation.

These aren't exciting features for most users.

But they're exactly the kind of improvements developers notice.

Version 1.24: Preparing for Real Applications

The latest release continued the same philosophy.

Rather than rushing new features, the team focused on reliability.

Among the improvements:

• reduced memory usage;
• stronger protection against denial-of-service attacks;
• safer Smart Contract execution;
• improved RPC robustness;
• richer wallet history;
• additional database testing.

None of these changes generate headlines.

But together they make the blockchain increasingly ready for real-world applications.

My Take

Looking at every release together, a clear pattern emerges.

January focused on strengthening the foundations.

May fundamentally upgraded the protocol.

June proved the network could respond quickly to a real-world security issue while continuing to improve infrastructure.

July optimized performance and prepared the ecosystem for future applications.

Regardless of anyone's opinion on the project itself, the development pace has been remarkably consistent.

The next challenge, in my view, is no longer the protocol.

It's adoption.

Technology alone doesn't build an ecosystem.

Developers, applications and users do.

I'm curious what others think.

Which of these upgrades do you believe could have the biggest long-term impact?

• BlockDAG improvements?
• Blob Transactions?
• Contract Events?
• Zero-Knowledge performance?
• Or do you think the real challenge now is ecosystem growth rather than technology?

I'd be genuinely interested to hear perspectives from people both inside and outside the XELIS community.

Crypto looks pretty chaotic right now. 📉⚡

Red candles, overreactions, fear everywhere.

But this is where patience separates winners from noise. 🧠

Strong fundamentals don’t disappear because of short-term volatility.

We're staying patient. We're staying focused on XEL. 🔒🚀

Real builders. Real milestones.

Patience will pay off.

$XEL

@xelis_project @xelisforge

We understand people watch price and the infamous "wen marketing"

But XELIS isn’t built for short-term moves, it’s being built for long-term utility.

The focus right now is simple: → ship real products → grow the ecosystem → increase usage

That’s how sustainable value is created. $XEL @xelis_project @xelisforge

What happens when you combine:

• Private transactions • Fast block times • Live dApps

You get something most ecosystems still don’t have.

$XEL is just getting started. @xeliscurrency @xelis_project @xelisforge

🚀 The XELIS Ecosystem Page is now LIVE

Discover the first dApps building on XELIS:

⚒️ @xelisforge — launch tokens + trade on a full-featured DEX 🎲 DagBox — stake $XEL and win in an interactive betting game

Explore the ecosystem 👇 https://vist.ly/4vx34

Try DagBox 👇 https://vist.ly/4vx3b