Next Gen
Smart Contracts
Quorlin is the native smart contract language for the Kortana blockchain. Featuring Java-like syntax with English readability, explicit mutability qualifiers, and compilation to ultra-fast 32-bit register bytecode.
// Native Quorlin Smart Contract (.ql)
contract TokenVault {
number totalSupply;
map<address, number> balances;
event Transfer(address indexed from, address indexed to, number amount);
constructor {
totalSupply = 1000000;
balances[caller] = 1000000;
}
reads number balanceOf(address owner) {
return balances[owner];
}
writes truth transfer(address recipient, number amount) {
number held = balances[caller];
require held >= amount, "insufficient funds";
balances[caller] = held - amount;
balances[recipient] = balances[recipient] + amount;
emit Transfer(caller, recipient, amount);
return yes;
}
}reads and writes explicitly express state transition contracts.number (uint256), truth (yes/no), and nothing.Engineered for Blockchain Scale & Safety
Quorlin and the Kortana Virtual Machine solve fundamental bottlenecks in smart contract security, developer ergonomics, and runtime execution efficiency.
Register-Based Architecture
Operates on 32 general-purpose 256-bit registers with fixed 32-bit instructions, completely eliminating stack manipulation overhead.
Explicit Mutability
Functions statically declare their exact execution model with reads and writes qualifiers, making unintended mutations impossible.
Full ABI Interop
100% compatible with Ethereum ABI specs. Seamless cross-calling between Quorlin and Solidity.
State Trie
Direct slot mapping and deterministic linear memory allocation provide incredibly fast state access.
Native Cryptography
Standard library primitives for Keccak256, Ed25519 signature verification, and safe arithmetic.
Complete Toolchain
Shipped with the qlc compiler, test runner, disassembler, language server (LSP), and full deployment pipeline for Kortana networks out of the box.
How Quorlin Executes on Kortana
From expressive source code to optimized register bytecode running on the Kortana Virtual Machine.
Write Quorlin (.ql)
Author clean, self-documenting smart contracts using English keywords, explicit mutability, and strict types.
Compile with qlc
Lexer, AST parser, and semantic analyzer perform strict validation, type checking, and ABI signature generation.
KVM Bytecode (.kvm)
Emits compact 32-bit register instructions with a 18-byte structured module header and constant pool table.
Kortana Node Execution
Executed with register-level speed on the Kortana Virtual Machine against the global world state trie.
35 Comprehensive Chapters
Complete guides, specifications, code references, and architecture blueprints for Quorlin and KVM.
1. Introduction to Quorlin
Core design philosophy, language vision, primitive type matrix, and minimal token contracts.
2. KVM Architecture
Register files (r0-r31), 32-bit instruction encoding, constant pool, and binary module specs.
5. Variables & Mutability
Reads vs writes semantics, immutable state bindings, and memory variable lifecycles.
10. Smart Contract Anatomy
Structure of contracts, state storage fields, event definitions, and constructor instantiation.
17. Security Features
Reentrancy protection, integer arithmetic overflow safety, and strict assertion guards.
31. Token & Resource Standards (KRS)
KRS-20 fungible tokens, KRS-721 NFTs, and the complete 12 Kortana Resource Standards.
Everything You Need to Know
What is Quorlin and what is its role in Kortana?
Quorlin is the native smart contract programming language of the Kortana blockchain. Saved with the .ql file extension, contracts written in Quorlin compile down to low-level register bytecode executed by the Kortana Virtual Machine (KVM).
How does the register-based KVM differ from the EVM stack?
Unlike the Ethereum Virtual Machine (EVM) which relies on stack operations (PUSH, POP, SWAP, DUP), the KVM operates directly on a fixed register bank of 32 256-bit registers (r0–r31) and fixed 32-bit instruction encodings, substantially improving execution speed and reducing bytecode size.
Can Quorlin contracts interact with existing Solidity contracts?
Yes. Quorlin natively supports Ethereum’s Application Binary Interface (ABI) and standard Keccak-256 function selectors. Quorlin contracts on the Kortana network can seamlessly execute cross-contract calls to existing Solidity contracts and standard Ethereum tooling.
What are the primary type keywords in Quorlin?
Quorlin uses human-centric primitives: number (256-bit unsigned integer / uint256), truth (boolean with literals yes and no), address (20-byte account), text (dynamic string), and nothing (void return).
Start Building on Kortana with Quorlin
Explore the comprehensive documentation, learn KVM internals, and deploy your first secure smart contract.