Internet-Free
Apocalypse-Proof
Blockchain Protocol
SuperLexicon is a Radio-defined-Blockchain that bypasses the Internet, ISPs, switches, and even the ubiquitous TCP/IP stack. Designed to perform halt-free sub-routine executions, across nodes within a 500 meter radius, using a low-powered radio (16-158mW).
Censorship & Control
Traditional networks rely on government-monitored gateways and corporate DNS routing. This makes standard systems highly vulnerable to centralized shutdowns, firewall blackouts, and state-level traffic control.
Infrastructure Failure
Standard blockchain nodes depend on physical routers, hardware switches, and global TCP/IP backbones. If physical fibers are severed or public power grids fail, validator coordination immediately halts.
Tactical & Rural Range
Rural areas, dense wilderness, and military operational zones lack cellular towers and broadband infrastructure. Under these conditions, coordinators cannot synchronize chronological messages.
Pluggable Multi-Transport Topologies
SuperLexicon separates physical network transport details from the core consensus business logic. The `TransportRouter` directs traffic across multiple radio and IP-based backends.
LR2021 FLRC Radio (Primary Transport)
The primary deployment transport and core protocol breakthrough. Communicates over USB CDC with an nRF54L15 MCU executing burst radio firmware at 915 MHz with 1.2 MHz bandwidth, routing frames directly across a dual-antenna RF path.
- Max Air Pacing: ~46 µs / byte
- Packet Splitting: 500B (votes) / 600B (blocks)
- Interframe Delay: 1200 µs (minimum)
LAN IP Multicast
High-bandwidth local network transport. Bypasses radio limitations to simulate sub-millisecond local validator roundtimes.
- Protocol: UDP Multicast / TCP Fallback
- Throughput: Gigabit LAN line rate
- Use Case: High-performance private validation
WAN Fallback
Standard WAN internet transport using libp2p. Includes Noise secure channel, Yamux stream multiplexing, and Kademlia DHT peer lookup.
- Security: Noise Handshake (secp256k1)
- Gossip: libp2p GossipSub Channels
- Protocols: TCP / WebSockets
Recommended Consensus Phase Timings by Transport Backend
Core consensus phase durations are highly dependent on the underlying transport backend's capacity, airtime limits, and network latency profile. Recommended timings for a standard 4-validator network:
| Transport Option | 1. Txns Propagation | 2. Execution Proposals | 3. Block Broadcasting | Total Round |
|---|---|---|---|---|
| LR2021 FLRC Radio | 8.0s | 5.5s | 2.5s | 16.0s |
| LAN IP Multicast | 0.05s | 0.03s | 0.02s | 0.10s |
| WAN TCP/IP Fallback | 0.6s | 0.4s | 0.2s | 1.2s |
3-Phase Consensus & Virtual Token Ring
Observe the transaction propagation, execution proposals, and broadcast phases in a simulated 4-node network. Toggle Byzantine modes, simulate transaction loads, and inspect how consensus resolves in real-time.
Window Round Timeline
Independent Subnets & Shared Backhaul
Observe multi-subnet transaction routing and backhaul synchronization. Local nodes consensus internally within subnets before merging state over the backhaul mesh.
Subnet Round & Backhaul Timeline
Pluggable Virtual Machines
Depending on hardware deployment profiles, SuperLexicon configures alternative virtual execution sandboxes to isolate state mutations.
WASMtime Rationale
Designed for cloud validators and high-spec gateway nodes. Compilation to native machine code ensures that compute-heavy contracts (like cryptographic verification or complex loops) execute in sub-milliseconds, amortizing compile latency.
Embive Rationale
Designed for edge burst transmitters. The interpreter sandbox has virtual memory boundaries implemented directly in software. This avoids heavy memory manager states, enabling execution of tiny binaries directly on radio transceivers.
Comparison: WASMtime vs. Embive RISC-V Sandbox
WASMtime executes WebAssembly via AOT/JIT compilation on high-performance hosts, while Embive interprets RISC-V instructions directly, optimizing for sub-microsecond cold starts and minimal device footprints.
| Metric / Feature | WASMtime VM (WebAssembly) | Embive VM (RISC-V Sandbox) |
|---|---|---|
| Execution Style | Ahead-of-Time (AOT) Compiled Machine Code | Instruction-by-Instruction Interpreter Sandbox |
| Cold-Start Instantiation | ~250 µs – 1.2 ms (Module load, JIT, verification) | < 1 µs (Instantaneous memory copy start) |
| Execution Speed & Latency | Near-Native (High execution throughput) | ~50x slower than WASMtime (Sufficient for simple operations) |
| Memory Overhead | ~15 MB – 40 MB (Requires full allocator runtime) | < 16 KB (Extremely lightweight static footprint) |
| Deterministic Memory Limiting | Implemented via dynamic runtime constraints | Enforced via static soft page-boundaries in flash/RAM |
Deterministic Smart Contract Environment
SuperLexicon smart contracts are compiled binaries optimized for low-bandwidth wireless transmission and predictable, sandboxed execution.
Supported Languages
Developers compile contracts in **Rust** (using the bare-metal RISC-V or WASM targets) or standard **C/C++**. Programs are compiled with `no_std` and zero memory allocation frameworks to run deterministically on low-power nodes.
Execution Safety
The execution runtime bans all non-deterministic operations. Floating-point operations, thread spawning, and hardware clock reads are disabled. All interactions with account states occur through safe, sandboxed system calls.
Deterministic Rust Contract Template
Rust (no_std)A template showing account state mutation and logging via host system calls:
#![no_std]
#![no_main]
// Link host system calls for state storage and events
extern "C" {
fn sys_read_state(key_ptr: *const u8, key_len: u32, val_mut_ptr: *mut u8, val_max_len: u32) -> i32;
fn sys_write_state(key_ptr: *const u8, key_len: u32, val_ptr: *const u8, val_len: u32) -> i32;
fn sys_log(msg_ptr: *const u8, msg_len: u32);
}
// Entrypoint executed by the sandbox engine
#[no_mangle]
pub extern "C" fn execute() -> i32 {
let key = b"counter_state";
let mut buffer = [0u8; 4];
unsafe {
// 1. Fetch current transaction count from account state
let bytes_read = sys_read_state(key.as_ptr(), key.len() as u32, buffer.as_mut_ptr(), 4);
// 2. Increment transaction counter deterministically
let mut counter = if bytes_read == 4 {
u32::from_le_bytes(buffer)
} else {
0 // Initialize if state is empty
};
counter += 1;
// 3. Write updated counter state back to persistent storage
buffer = counter.to_le_bytes();
sys_write_state(key.as_ptr(), key.len() as u32, buffer.as_ptr(), 4);
// 4. Log completion event to block receipts
let log_msg = b"Transaction count updated successfully";
sys_log(log_msg.as_ptr(), log_msg.len() as u32);
}
0 // Return success status code
}
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
loop {}
}Contract Lifecycle
sl_deployBytecode JSON-RPC endpoint. The node stores the bytecode and returns a 32-byte code_hash (Keccak256).Primary Use Case
Anywhere where infrastructure and trust is limited, and fault-tolerant sequencing is essential.
Specific Use Cases
How We Compare
Contrasting SuperLexicon's Radio-Defined-Blockchain against other offline peer-to-peer solutions.
| Feature | SuperLexicon | BLE-based Bitchat | Standard LoRa Apps |
|---|---|---|---|
| State Sequencing | Deterministic Consensus | Chaotic / Out-of-Order | Chaotic / Out-of-Order |
| Smart Contracts | Yes (Native VM) | No | No |
| Effective Range | City-wide Mesh | Short-range (<100m) | City-wide |
| Bandwidth Strategy | Hybrid (2.4GHz + Sub-GHz) | BLE only | Sub-GHz only (Slow) |
| Fault Tolerance | Byzantine Fault Tolerant | None | Basic ACKs / Retries |
Protocol & Community Road Map
Tracking the dual-track evolution of the SuperLexicon protocol and the independent community-driven subnets powering the mesh.
Already Implemented
- 3-Phase Deterministic Consensus for strictly ordered state execution over chaotic RF links.
- Multi-Radio Support for Subnet and Backhaul Comms: bridging high-speed 2.4GHz FLRC with long-range Sub-GHz routing.
- Native On-Device Virtual Machines with support for WASM, Rust, and Python smart contracts.
- Independent Subnet Partitioning allowing community deployment of isolated micro-grids.
Future To-Dos
- Hardware Engineering: Finalize a USB plug-and-play device featuring multi-frequency MIMO to achieve massive bandwidth and TPS multiples via simultaneous tx/rx.
- Firmware Transport Layer: Evolve the consensus engine into a base transport protocol (like TCP/IP) within the device firmware, enabling HTTP/FTP-like services above it.
- Sample Applications: Build reference apps spanning from simple localized messaging to complex matching engines for the immediate physical exchange of goods and services.
- Hobbyist Communities: Tap into and nurture grassroots hardware and radio hobbyist communities to organically grow the physical node network.
- Satellite / LEO Mesh Integration: Bridging disconnected terrestrial subnets via satellite links.
- Zero-Knowledge Proofs (ZKPs): Ensuring absolute privacy for on-mesh transactions without bloat.
Dual-Track Development
Protocol Evolution
Base Consensus Engine
Implemented the 3-phase ordering loop over simulated chaos.
VM Integration
Embedded WASM, Rust, and Python runtimes directly into the node software.
MIMO Hardware & Firmware Protocol
Finalizing multi-frequency USB devices and migrating consensus into a firmware-level transport protocol.
Cross-Subnet Routing
Atomic state swaps and message passing between disjoint mesh networks.
Community Subnets
Testnet Alpha (Simulator)
Initial community stress-testing of the RF topology and packet loss resilience.
Research Foundation
Setting up a Foundation for the Research of a Decentralized Internet Topology to formalize grassroots development.
Grassroots Apps & Hobbyist Network
Engaging hobbyist communities to pilot reference applications (local messaging, matching engines).
Energy-Trading Subnet
First community-driven microgrid utilizing 2.4GHz for localized solar settlements.
Disaster Recovery Mesh
Widespread deployment of emergency Sub-GHz relays for off-grid coastal regions.
Active Repositories & Firmware
SuperLexicon is fundamentally open source. You can compile the core protocol nodes, burn the fast long range communication radio firmware on developer kits, or explore our sister projects.
superlexicon/lr2021-flrc-firmware
The low-level firmware executing on the nRF54L15 MCU. Written in C, it implements packet serialization, half-duplex slot scheduling for the LR2021 radio, and antenna path fast-switching logic.
superlexicon/ni6
The first ever decentralized open source intelligence server that verifies identities and proof-of-live through video selfies, analyzes documents such as passports, bank statements, tax certificates and id cards, and facilitates decentralized key recovery via Shamir's Secret Sharing algorithm.
superlexicon/usp
Forked to declare smtc_modem_hal_radio_irq_kick() in the HAL API. This re-injects a lost radio IRQ (since a level-held line with an edge-triggered pin loses edges during radio reconfiguration, stalling transactions).
superlexicon/usp_zephyr
Forked to implement smtc_modem_hal_radio_irq_kick() for Zephyr, invoking the registered IRQ callback as the GPIO ISR would. (Note in lr20xx_board.c: keep EDGE triggering — LEVEL broke IRQs on nRF54L15 GPIOTE; recovery is the app's job).
Forging the Decentralized Frontier
We are a collective of distributed systems engineers and radio frequency enthusiasts who believe your messages should not need to travel around the world to get to the person 100m away from you.
Who We Are
Superlexicon is both the research arm and open source software line of IMMIN, a software engineering company that thrives at the intersection of distributed systems and investment finance, helmed by Mano Thanabalan.
Mano Thanabalan
Chief Technology Officer
Privacy Policy
Last Updated: August 27, 2026
SuperLexicon ("we", "our", or "us") respects your privacy. This Privacy Policy explains our practices regarding the collection, use, and disclosure of information when you visit our website.
1. Information Collection
We do not require user registration. We do not actively collect, store, or process any personally identifiable information (PII) from our visitors. Our website is designed solely for informational and research purposes.
2. Cookies and Tracking
This website uses only essential cookies required for basic site functionality. We do not use third-party tracking, analytics cookies, or advertising pixels.
3. Data Security
While we do not collect personal data, we utilize standard industry practices to ensure the security of our website's infrastructure.
Terms of Use
Last Updated: August 27, 2026
By accessing or using the SuperLexicon website, you agree to be bound by these Terms of Use.
1. Informational Purposes Only
All content provided on this website is for informational and educational purposes only. The SuperLexicon protocol is an experimental, open-source research initiative into decentralized internet topologies.
2. Intellectual Property
Unless otherwise stated, the concepts, whitepapers, and software architecture described here are open-source. However, the specific branding, website design, and logos are the property of the SuperLexicon research team.
3. No Warranties
The website and its contents are provided on an "as-is" and "as available" basis without any warranties of any kind, either express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement.
Legal Disclaimer
Last Updated: August 27, 2026
1. Not Financial or Investment Advice
The information on this website does not constitute investment advice, financial advice, trading advice, or any other sort of advice. SuperLexicon is a network protocol research project. Any mentions of "tokenomics", "smart contracts", or "exchanges" are strictly related to the technical architecture of distributed systems and do not represent a financial asset or security.
2. Regulatory Compliance
Users are responsible for ensuring that their use of radio frequencies (RF) and decentralized networks complies with the local laws and regulations of their jurisdiction, including but not limited to FCC regulations in the United States or equivalent local telecommunications bodies.
3. Experimental Technology
The SuperLexicon protocol and associated hardware are in active development. Deploying nodes, participating in testnets, or relying on this technology for mission-critical infrastructure is done entirely at your own risk.