OP_NET smart contracts compile to WebAssembly. That means they can be written in over 20 languages, including Rust, Python, JavaScript, Go, C and AssemblyScript. There is no new VM to learn. The language you already use is the language you build with.

AssemblyScript v0.28.19 released! devtalk.com/t/247250 #AssemblyScript #TypeScript # #devtalk

This is groundbreaking !

fui-as: SwiftUI/WPF-style retained UI in AssemblyScript, powered by a fast C WASM Runtime. No HTML/CSS/JS. Tiny payloads real accessibility. dev.to/zionsati/i-was-in-a-m… Demo: fui-as-demo.effindom.dev @AssemblyScript #WebAssembly #AssemblyScript #WASM #CPP #TypeScript

Why @RetiumChain Chose WASM Instead of EVM Most blockchains tell developers what they can build. @RetiumChain is trying to remove those limits. For years, smart contract development has largely revolved around EVM ecosystems. While powerful, they often lock developers into specific languages, execution models, and design constraints. Retium takes a different approach. Instead of building around the EVM, it uses a WASM-based smart contract engine — opening the door to languages like Rust, C/C , and AssemblyScript while benefiting from faster execution, safer memory handling, and greater flexibility. But the interesting part isn't just performance. It's what that performance enables. Developers aren't limited to simple token contracts. They can build advanced DeFi systems, governance frameworks, real-time applications, and custom modules that interact directly with Retium's underlying logic layer. The goal isn't to make smart contracts slightly better. It's to create an environment where developers spend less time working around infrastructure limitations and more time building actual products. Because the future of blockchain won't be defined by who writes the most contracts. It will be defined by who gives builders the fewest constraints. #retium #retiumchain

One thing I find interesting about @RetiumChain is its WASM-based smart contract engine. Retium supports WebAssembly (WASM), allowing smart contracts to be built with Rust, C/C , and AssemblyScript. Multi-language support adds flexibility. #Retium #RetiumChain #Web3

Most L1 launches start with the token. Retium will start with the toolkit. Phase 3 isn't just a testnet milestone. It's when builders can finally interact with the chain in public, and the chain they'll be building on is structurally different from anything in the EVM world. Retium uses WASM, not EVM. Contracts can be written in Rust, C , or AssemblyScript. Solidity-native tooling doesn't apply. For most builders, that's a context shift: 1. No Hardhat, Foundry, or Remix 2. Memory safety enforced at the 3. language level, not the VM 4. Smaller bytecode, closer to bare-metal execution 5. Storage and execution models differ from EVM patterns WASM as a contract VM isn't new. Polkadot and NEAR have used it for years. What's new is putting it inside a deterministic, no-leader, USD-fee chain targeting RWA flows. The Phase 3 question for developers isn't "should I switch to Rust?" It's "what does building look like when the underlying chain is structurally different from anything I've shipped before?" Phase 4 brings the RTM token launch and mainnet. Phase 3 brings the toolkit. The sequence matters. Most chains launch token first and hope ecosystem follows. Retium chose the opposite, toolkit before token. That's a different incentive structure for builders. Whether it produces a stronger ecosystem or a slower one is a Phase 3-into-Phase 4 question. But the philosophical bet, let builders shape the chain before speculators do, is clearer than most L1 launch plans I've seen.

KasGraph is now feature-complete. Think of it as The Graph rebuilt for Kaspa, except not lazily ported from an account-chain worldview. Kaspa is not Ethereum with different branding; it is a UTXO-based BlockDAG with Covenant IDs, lineage, forks, native assets, and parallel history, so the data layer has to respect that architecture from the ground up. KasGraph does exactly that. You define a schema, write an AssemblyScript mapping, build, deploy, index, and query through GraphQL or MCP. That matters because this is not only for dashboards and explorers, it is AI-native from day one, letting agents query structured Kaspa data without manually stitching together RPC calls or writing raw GraphQL. The full pipeline is live: build, deploy, index, query. Multi-tenant, hot-reloadable, and able to pick up new deploys without restarting the node. Under the hood it supports real covenant fingerprints from live compiles, OpenSilver core patterns, native KCC20 controllers, legacy KRC-20/KRC-721, BlockDAG-aware reorg handling, typed subgraph schemas, relation resolution, covenant lineage, fork-aware DAGs, and Proof of Indexing with an independent verifier. The only remaining piece is operational: deploying the hosted site at kasgraph.com with log streaming and auth layered in. MIT licensed, public from the first commit. Kaspa finally has structured data querying. github.com/trillskillz/KasGr…

3am Yet another epiphany. Bare metal C v Rust. Linear serial buffer. #assemblyscript #ziglang #webGPU

The Journey of $NEAR: From Layer 1 to AI NEAR Protocol originally began its journey as a Layer 1 blockchain heavily focused on scalability and usability, founded back in 2017 by @General_Illia and Alexander Skidanov. Since then, @NEARProtocol has gone through two major phases that completely reshaped the direction of the ecosystem. 1/ The pure Layer 1 era (2020-2023) During its early years, NEAR became widely recognized for its Nightshade sharding architecture designed to achieve high scalability while preserving decentralization. Simple Nightshade launched in 2021 followed by multiple sharding upgrades afterward, positioning NEAR as one of the more technically ambitious Layer 1 ecosystems at the time. The protocol also differentiated itself through: -  Proof-of-Stake consensus. - Carbon-neutral infrastructure. -  Developer-friendly tooling using Rust and AssemblyScript. But like most Layer 1 ecosystems during the 2022-2023 bear market, NEAR struggled heavily after the broader market collapse. $NEAR dropped from its ATH around ~$20.42 to below $2 while TVL remained relatively weak despite several DeFi applications like Ref Finance continuing to build through the downturn. 2/ The transition toward AI infrastructure (2023-2025) This was honestly the real turning point for the entire ecosystem. $NEAR increasingly recognized that future blockchain infrastructure would eventually need to support AI agents capable of transacting, coordinating assets, and operating autonomously across multiple ecosystems. That realization gradually transformed NEAR into what is now increasingly positioned as a “blockchain for AI.” Between 2024-2025, the ecosystem introduced several major upgrades: - Nightshade upgrades Phase 2 sharding improvements. $NEAR reportedly achieved benchmarks approaching 1M TPS on commodity hardware during 2025 testing environments. - NEAR Intents. An intent-based architecture allowing seamless chain abstraction and cross-chain execution for both users and AI agents without relying on complicated bridge UX. By 2026, Intents had already processed more than ~$19B in cumulative volume while generating roughly ~$32-33M in fees fully directed toward $NEAR buybacks. Daily volume occasionally surpassed ~$90M. - The NEAR AI stack Including AI Cloud infrastructure with TEEs for private inference, IronClaw runtime for autonomous agents, and an emerging Agent Marketplace ecosystem. The broader vision focuses heavily on user-owned AI, encrypted model execution, and verifiable compute systems. Since this transition toward AI infrastructure accelerated, NEAR’s ecosystem metrics have improved significantly: - Daily active addresses increased roughly 240% YoY surpassing 800,000 by Q4 2024. - Monthly active users climbed toward ~46-51M. - TVL expanded nearly 187% during 2024 and surpassed ~$600M during several periods throughout 2025. - Developer count increased from roughly ~850 to over 1,200 with more than 50 AI-focused teams actively building on the ecosystem. From my perspective, $NEAR transition toward AI feels far less like a reaction to market trends and much more like a return to the project’s original vision. It honestly feels much closer to a return toward the original DNA of the project itself. Illia Polosukhin came from a deep AI background at Google long before the current AI narrative exploded across crypto. That foundation is something very few Layer 1 ecosystems genuinely possess. While Ethereum and Solana remain heavily focused on DeFi, trading infrastructure, and memecoin activity. NEAR is increasingly positioning itself around infrastructure for the emerging Agentic Economy, a world where AI agents can own assets, transact independently, and operate seamlessly across multiple chains. And honestly, this could eventually become one of the most important long-term bets across the entire crypto industry if AI agents truly become mainstream over the next decade. This may end up being the defining move that brings @NEARProtocol back toward its prime once again. DYOR.

I am developing a new project called KasGraph. KasGraph is the data layer Kaspa needs if applications are going to move beyond raw transactions and into usable, real-time infrastructure. Every wallet, marketplace, explorer, DeFi interface, AI agent, or covenant-based app eventually has to ask the same basic questions: what tokens does this address own, what happened to this covenant, which NFTs were minted, what transfers occurred, what proofs were submitted, and how did the state change over time? Without a shared indexing layer, every developer is forced to rebuild that logic alone. That means slower apps, duplicated infrastructure, fragile backends, and a worse user experience. KasGraph fixes this by acting as a subgraph-style indexing protocol built specifically for Kaspa. Developers define schemas in GraphQL SDL, write TypeScript event handlers that compile to WASM through AssemblyScript, and KasGraph materializes the indexed data into Postgres with per-block proof-of-indexing checkpoints. In plain English: developers describe what they want to track, KasGraph watches Kaspa, remembers the important events, and makes that data instantly searchable. The technical stack is designed around where Kaspa is going, not where legacy chains already are. KasGraph supports KIP-20 Covenant IDs, native KRC-20 and KRC-721 detection, Toccata covenant primitives, OpenSilver patterns, Groth16 proof detection under KIP-16, BlockDAG-aware reorg handling, multi-RPC failover, and KIP-20 confirmation finality. Subgraphs can subscribe to typed events without every developer writing custom detection logic from scratch. The interface layer exposes the same indexed data through GraphQL, MCP, gRPC streaming through KasStream, and WebSocket subscriptions. Same data, four surfaces. Apps can query it, dashboards can stream it, wallets can subscribe to it, and AI assistants can understand it through MCP in plain English instead of raw chain parsing. Performance targets are explicit: sub-30-second indexing latency, p95 query latency under 200ms, and sub-second streaming. MIT licensed. Open source from the first commit. KasGraph is not just an indexer. It is the connective tissue between Kaspa’s execution future and the applications people will actually use. Builders are welcome. github.com/trillskillz/KasGr…

What this means in practical terms is simple. Different layers specialize in different responsibilities. 🎯The base layer prioritizes security. 🎯The execution layer focuses on smart contracts. 🎯The ZK layer handles extreme scalability and computation. That modular structure matters because monolithic blockchains eventually hit bottlenecks when every transaction, contract, and computation competes for the same network resources. PYRAX is trying to avoid that limitation entirely. One part of the architecture I find especially interesting is the support for multiple virtual machine environments. Most chains force developers into one ecosystem. PYRAX supports: ✅ Solidity and Vyper for EVM developers ✅ Rust and AssemblyScript through WASM ✅ Cairo for StarkNet compatible ZK applications That opens the door for a broader developer economy instead of limiting innovation to one programming environment. The network also integrates recursive zero knowledge proofs on Layer 3, allowing transaction batches to be compressed and verified efficiently while still inheriting Layer 1 security guarantees.

📚 ピックアップ ✨ TypeScriptエンジニアがWebAssemblyのメモリモデルを理解するため、AssemblyScriptを使い、オブジェクトが線形メモリ上でどう表現されるかを詳細に解説しています。クラス、配列、文字列のメモリ配置やパディング、GCヘッダの実態が学べます。 zenn.dev/yuki_ayano/articles…

Coding agents are actually, what made as-lan possible. AssemblyScript only compiles to WASM and JAM needs PVM. Few months ago I instructed AI to build WASM->PVM re-compiler. I wasn't hoping for much, but surprisingly github.com/tomusdrw/wasm-pvm produces decent results!

#tskaigi_leverages #TSKaigi2026 AssemblyScriptには配列っぽいのが3種類あるらしい ArrayBuffer, TypedArray, Array<T> それぞれメモリ上での役割が違うってよ

「TypeScriptエンジニアのためのWASMランタイム入門：AssemblyScriptから理解するメモリの実態（ayano）」を聞く #TSKaigi2026 #tskaigi #tskaigi_leverages

Retium ditches the traditional EVM for a WebAssembly (WASM) smart contract engine. This is a game-changer for developers. Instead of being restricted to Solidity, developers can build dApps using high-performance languages like Rust, C/C , and AssemblyScript. WASM is faster, memory-safe, and allows for complex on-chain logic with a fraction of the overhead seen on EVM chains.