Marcos

Visionário de investimentos.

[Zelcore @zelcore_io]

Kaspa fees aren't a flat number. They scale with transaction mass.

Zelcore builds your KAS transaction offline first, measures its real mass, then prices the fee from a live network estimate. You see the actual fee before you sign, and the network stops rejecting it.

[IzioDev @IzioDev]

@Wevn_Space je pense qu'il est même plus adapté de débuter sur Argent. Silverscript est une base, une fondation, sur laquelle Argent se repose.

c'est le message pour lequel j'opterai pour nos builders.

https://t.co/ogtxyuzQcd

[Hans Moog @hus_qy]

A lot of people think what makes Kaspa unique is the technology.

But the technology is really the consequence of a deeper philosophical difference.

Most crypto projects ask: How can we maximize performance without sacrificing decentralization?

Kaspa asks: How can we maximize decentralization without sacrificing performance?

That slight inversion of priorities changes everything.

It changes what the system optimizes for, which tradeoffs are acceptable, and ultimately what kind of threat model matters.

Kaspa and in particular the upcoming DAGKnight fork are built around the idea that a decentralized monetary network should remain resilient even under extreme failure scenarios like global infrastructure disruption, war, or other large-scale breakdowns.

Because fast digital coordination should not force people to choose between trusting a small group of node operators over a small group of banks.

For many applications, that distinction may not matter.

But for the applications where credible neutrality, censorship resistance, and resilience matter most, that ideological edge is the product.

Kaspa does not merely compete at the technological level.

It competes at the philosophical level and the technology is just the downstream consequence of following that philosophy to the end.

[Hans Moog @hus_qy]

Hey guys,

It's been a while since my last post, and I feel almost bad for not posting anything for such a long time 🙈

Unfortunately, I caught a really nasty infection on my way home from the KAS meetup and have been stuck in bed with a high fever and brain fog for the last few weeks.

I'm still not completely back to normal, but since I'm finally starting to have a bit more energy, I wanted to use the opportunity to share some thoughts about the meetup, because I think it will turn out to have been extremely influential for the future of Kaspa.

For anybody who doesn't know what I'm talking about: about 3.5 weeks ago, KAS organized an internal meetup between core contributors (and some additional community developers) at an undisclosed location in Europe.

When I first learned about the plans for this meetup, I didn't really know what to expect.

I've been to developer meetups before, but those were traditionally very narrow and task-focused. E.g. you got a team together to work on a specific problem that was difficult enough to deserve the shared attention of everyone involved.

In the case of Kaspa, however, we have relatively small and independent teams working on a number of different topics in parallel, such as vprogs, covenants, SilverScript, Argent, etc.

There are, of course, interfaces between these topics, but they all have their own independent designs and problem spaces.

This independence of developers is one of Kaspa's biggest strengths, but it also creates a situation where not everybody is always fully up to speed with what is happening elsewhere in the project.

For me personally, this is probably the biggest obstacle to becoming an effective communicator.

To feel confident discussing things publicly, I need to develop a deeper understanding and intuition for the subject. And that requires knowing not only the final design or code, but also the roads that weren't taken and the mountains that had to be climbed along the way.

What Kaspa really needed, wasn't a narrow, task-focused meetup, but a broad, vision-building one: something that connected the dots and allowed the different teams to develop a deeper understanding of each other's work, and ultimately see how all of it fits together as a coherent whole.

And the reason I'm telling you all of this is that this is exactly what the meetup turned into.

A week of open sessions and discussions covering the different development efforts, giving everyone the opportunity to build that deeper shared understanding.

I think it was a huge success!

I'll write a little more over the coming days about specific topics like Argent (which I really like), but I also have quite a lot to catch up on after being sick for so long.

@Max143672 did a really good job working through a lot of the open tasks around vprogs, and I now have a lot of code to review :'P

[Kaspa Kii @KaspaKii]

Kii will be at the 16th @DiiDesertEnergy Leadership Summit in Istanbul, 29 Sept – 1 Oct.
This is not a crypto event. It is the annual gathering of the companies actually building EU–MENA clean energy systems and markets.
Look at their Clean Energy Pyramid. @pvson

One of the structural layers is Trusted Information: security and optimality through trusted data, AI, blockchain and cyber security.
That is the layer Kaspa was built to carry. Energy markets need an information and settlement substrate that is:

• fast enough for trade
• neutral enough for counterparties who do not trust each other
• cheap enough to attach certificates, attributes and provenance to every electron and molecule
• secured by proof of work, not a validator committee

Last year we introduced Kaspa’s BlockDAG to this network. This year the conversation is trusted trade: registries, certificates, settlement and auditability that can travel across borders without a central operator.

Kaspa as the information carrier for clean energy markets.#Kaspa #Kii

[BaN𐤊ℚuOτE @BankQuote]

SilverScript v1 marks a significant step in making Kaspa’s programmability accessible to a broader developer base. Developers can now express complex spending conditions and stateful contracts through readable source code that compiles directly to Kaspa Script. The underlying capabilities become much easier to build with, inspect and maintain.

The example from the announcement captures why this matters: a token mechanism that previously required thousands of lines of raw opcodes can now be expressed in roughly 60 lines of SilverScript. That reduces how much low-level complexity developers must manage directly. It could shorten development cycles, simplify review and make useful contract patterns easier to share. The improvement concerns developer effort; it does not automatically imply equivalent reductions in transaction size or fees.

Stateful contracts allow rules and application state to persist through successive UTXOs. Each transaction consumes existing state and creates its permitted successor. This provides a foundation for controlled token issuance, escrow, recurring payments, restricted treasuries and other financial agreements whose conditions are enforced by transaction validation.

The AI implications are also practical. Readable types, functions and explicit conditions give coding assistants a clearer structure to generate, explain and test. That could accelerate experimentation, although readable code and AI-generated code still require rigorous review. A contract can enforce a flawed rule perfectly.

Argent extends this foundation by organizing contracts into applications composed of actors that own state and coordinate through atomic transactions. SilverScript provides the contract language; Argent adds abstractions for managing relationships across contracts and applications. Argent still needs further auditing and hardening.

The broader implication is a lower barrier between Kaspa’s protocol capabilities and usable applications. SilverScript v1 gives developers a released foundation to build upon. What matters next is whether that produces reusable libraries, independently reviewed contracts and applications people consistently use. This is where infrastructure begins translating into an ecosystem.

[IzioDev @IzioDev]

i will start by saying there isn't a unique resource that can realistically target all audience groups.

abstractions are built bottom-up and not top-down, that's just how it works, and it's still an on-going process.

i can quickly identify three audience groups:
- system design engineer
- builders
- average Joe
obviously, one can identify themself in multiple category.

at this stage, i'm feeling confident to speak and create contents to the first two groups, while still trying to address the last one.

you're still touching a crucial point which is the lack of documentation around external builders. they don't need to care about all of the technical aspects, they likely want to install a soft, follow cookbooks, and press deploy: this will be built over time.

only yesterday we had the first SilverScript stable release. putting it in the bigger picture, i believe SilverScript will be a foundational layer for builders, that will likely only interact with Argent (that is more complete and powerful for product builder needs)

[KuMining @KuMiningCom]

KAS mining doesn’t come in one fixed package.

KuMining currently supports mining periods from 7 to 90 days, with entry starting from single-digit USDT—giving users more room to choose the scale and duration that fit them.

[Shai (Deshe) Wyborski | Parallel Thoughts @DesheShai]

Very good direction for $kas.

UTXO programmability is one of the most sensible, yet overlooked, approaches to functionality. Kaspa deserves a scripting language tailored to its unique properties.

The difference between devs who create and "devs" who destroy has never been more palpable.

[IzioDev @IzioDev]

this is a good opportunity for me to expand on storage.

no meta-data really is "stored on-DAG", when we say that, we likely refer to "witnessed": a revealing event to feed the execution engine with full data.

Kaspa decouples the DA (data availability) layer with the execution layer, for example through the pruning strategy: only the last ~30hrs of "non-consensus important" data are kept. or for example the program model: builders deploy a hash to the covenant and its state, and only these 32-bytes represents the covenant at the UTXO-level.

without this decoupling property, i likely wouldn't be able to run a **full** node on my laptop.

in this context, on-DAG image concept you're referring to would likely be projected as: "i store an integrity hash of the image, while the image still is served externally".

essentially, we have to ask ourselves: who cares about the image integrity of an NFT (if there is an image attached to it at all)? the possible answers likely doesn't contain L1, meaning there will be no covenant program verifying image integrity.
in this context, the end-users might be the interested party, and as such, they could take the integrity hash (from covenant state, or other), take the actual image that is being served externally and verify the image is the correct one

[IzioDev @IzioDev]

any remaining confusions between SilverScript x Argent x KCCs?
if yes, ask below :)

[Kaspa @KASPAglobal]

Kaspa’s miners earn the subsidy plus transaction fees.

As the subsidy declines, keeping total miner revenue steady in dollars requires more fees, a higher KAS price, or both. At a fixed price, every KAS lost from the subsidy needs a KAS in fees to replace it.

Cheaper electricity can improve a miner’s profit. It does not replace the revenue.

$KAS

[BSCN @BSCNews]

It is now possible to write readable Smart Contracts on Kaspa!

@Kaspaunchained announced the launch of Silverscript v1, a high-level smart contract language designed to streamline the development of complex, stateful applications on the Kaspa ledger.

The language removes the technical overhead of raw opcodes, reducing thousand-line implementations into 60-line, human- and AI-readable scripts.

This aims to foster faster innovation in UTXO-based finance.

The release marks the conclusion of an eight-month development cycle alongside the Toccata framework, providing developers with the tools to build sophisticated token mechanisms and layered abstractions.

"This completes the journey we started eight months ago with Toccata — it's finally possible to write human- (and AI-) readable smart contracts on Kaspa," core developer @OriNewman stated.

Worth noting that the KCC20 standard is still not live yet.

[KuMining @KuMiningCom]

https://t.co/rEcdWs9Tfh

[L1‎𐤊aspa @KaspaLayerOne]

$KAS Trending on @X

[L1‎𐤊aspa @KaspaLayerOne]

🚨 Silverscript v1 is officially out! 🚨
​This completes the 8 month journey that started with Toccata. We can finally write human and AI readable smart contracts on $KAS.
​What used to take thousands of lines of raw opcodes for an early token mechanism can now be written in just 60 lines of code. It grew from just "CashScript with loops" into a full smart contract language handling complex, stateful contracts.
​Massive step for UTXO programmability on Proof-of-Work. Silverscript is setting the foundation, and Argent is coming next to add higher layers of abstraction.
​Link to the Github release: https://t.co/cVf4UmTD9u

[𝑹𝑬𝑪𝑶𝑵 @ReconProtocol]

SilverScript v1.0.0 is out.

Ori Newman just released the official v1.0.0 on GitHub.
4 contributors. 8 months of work since Toccata.

What this means:
It's now possible to write human and AI readable
smart contracts on Kaspa.

The same contract that required thousands of lines
of raw opcodes now fits in 60 lines of SilverScript.

Stack: SilverScript -> Covenants -> Argent -> dApps
The foundation is complete.

#Kaspa #NFA

[Marcos @Marcos604184119]

@OriNewman Muito insano #kaspa 1000%

[Marcos @Marcos604184119]

Muito insano #kaspa 1000%

[Kaspa Hub @KaspaHub]

JUST IN: Kaspa SilverScript v1 is live!
A full-fledged smart contract language capable of expressing complex, stateful contracts.

[Michael Sutton @michaelsuttonil]

After endless audits, reviews and refinement cycles, it’s finally here, ladies and gentlemen: silverscript 🩶📜