Roadmap | ALUX Network

Year 2027

2027

2027 Q1

Planned

Formal proofs in Lean of key system properties (Planned)
Testnet launch (Planned)

Year 2026

2026

2026 Q1

Done

Simplified replay mechanism for cross-block execution (Completed)
Introduced a new EVM sandbox for improved efficiency and simplicity (Completed)
Refactored TVM consensus, database, and framework for better modularity (Completed)
Implemented tests for cross-block execution and replay by lazy validators (Completed)
Developed TupleSpace Explorer to visualize state and execution progress (Completed)

2026 Q2

Done

Native Tolang parser (Completed)
Tolang compilation time const support (Completed)
Tolang language server and Tolang VS Code extension (Completed)
Refactored test framework (Completed)
Conduct full end-to-end integration testing of the system including the consensus layer (Completed)
Complete API implementation (Completed)
Develop node CLI (Completed)
Customized blockchain explorer for cross-block execution and atomic finalization visualization (Completed)
New trap based EVM sandbox (In Progress)
Integrate with Ethereum toolchain (In Progress)

2026 Q3

Done

Support for synchronous functions alongside the existing asynchronous functions, with closures and partial application (Completed)
Initial system registry, account abstraction, and capability claim and delegation contracts (Completed)
Simplified the TVM task scheduler and made concurrent execution easier to test (Completed)
Ledger-based execution context tracking for reliable revert across nested contexts (Completed)
Tolang reference interpreter for verifying compiler output (Completed)
Tolang code formatter, tolang! Rust macro, and IDE go-to-definition and rename (Completed)
TypeScript API client with typed bindings generated from the node's RPC interface (Completed)
New TVM interpreter with nested collections, loops, closures and initial gas metering (In Review)
New trap based EVM sandbox (In Progress)

2026 Q4

Planned

Implement logical clock and isolation-level enforcement mechanisms (WIP)
A "GDB" like TVM debug and observability tool (WIP)
Complete the cost accounting model (WIP)
Integrate with Ethereum toolchain (WIP)
Implement and test proof-of-stake (PoS) contract (Planned)
Implement synchronization and fault recovery mechanisms (Planned)
Implement garbage collection (Planned)
Deliver Solidity examples demonstrating smart contract / agent orchestration (async/await, join, select) (Planned)

Year 2025

2025

2025 Q1

Done

Refactored the whole system to an event-driven framework to enable concurrent transaction execution, block replay, and block proposing for maximum concurrency (Completed)
Implemented RPC endpoints and updated BlockGit to handle missing blocks (Completed)
Fixed memory leaks in BlockGit and improved its performance (Completed)
Introduced Weaklink to the BlockGit protocol and partially implemented it (Completed)

2025 Q2

Done

Implement and test Weaklink in the BlockGit protocol (Completed)
Introduce simple channel behavioral types to simplify TVM architecture and improve reliability (Completed)
Introduce test framework for randomly generated Tolang codes and CI integration (Completed)
Refactor replay logic (Completed)

2025 Q3

Done

Implemented a mechanism to execute, wake up, pack, and replay long transactions spanning multiple blocks and finalization fringes (Completed)
Refactored the database module to improve performance and efficiency (In Progress)
Refactored the TVM framework for improved modularization (In Progress)

2025 Q4

Done

Test cross-block execution without consensus (Completed)
Refactor the TVM framework for improved modularization (In Progress)
Specify and implement API endpoints (In Progress)
Design the logical clock and isolation level enforcement mechanism (Completed)

Year 2024

2024

2024 Q1

Done

Global registry implementation & testing (Completed)
Functional programming support from Tolang and TVM (Completed)
Supported thread-safe sequential computing on concurrent TVM (Completed)
Conducted preliminary EVM compatibility test (Completed)
Implemented EVM state storage to support read-committed isolation level (Completed)
Refactored code & performed comprehensive testing of correctness and replayability in TVM (Completed)

2024 Q2

Done

Refactored and unified the tuple space play and replay logic (Completed)
Implemented an external HTTPS call play and replay to demonstrate the capability to actively collaborate with Web 2.0 systems without oracles / relayers (Completed)
Initial implementation of the Blocklace consensus protocol (Completed)
Redesigned state management to reduce memory usage (Completed)
Designed logical clock data structure and algorithm used to enforce isolation levels (Completed)

2024 Q3

Done

Execution context to support reverting a part of execution (Completed)
Designed and initial implementation of BlockGit, a new consensus protocol (Completed)
A discrete event simulator to test consensus protocol implementation (Completed)
P2P module with initial integration for BlockGit (Completed)

2024 Q4

Done

Integrated BlockGit into the node platform (Completed)
Tested consensus protocol on Docker network (Completed)
Implemented conflict resolution algorithm in block merge (Completed)
Refactored storage module to support query and state commitment (Completed)

Year 2023

2023

2023 Q1

Done

Concurrent virtual machine opcodes implementation & test (Completed)
Concurrent transaction deterministic replay data structure (Completed)

2023 Q2

Done

Concurrent virtual machine execution & replay implementation (Completed)
Storage layer specification and implementation (Completed)

2023 Q3

Done

Storage layer test (Completed)
Concurrent virtual machine execution & deterministic replay test (Completed)
Special channel type specification and implementation (Completed)

2023 Q4

Done

Implemented new task manager for better error treatment and thread locality support (Completed)
Performance improved by introducing sequential computing support (Completed)
Special channel type test (Completed)
Utilized special channel types to simplify replay log (Completed)