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.
The same vault, with fewer ways to lose it
Identical TokenVault in both languages. Hover a numbered difference to spotlight its lines Quorlin on the left, Solidity on the right.
1// Native Quorlin Smart Contract (.ql)
2contract TokenVault {
3 number totalSupply;
4 map<address, number> balances;
5
6 event Transfer(address indexed from, address indexed to, number amount);
7
8 constructor {
9 totalSupply = 1000000;
10 balances[caller] = 1000000;
11 }
12
13 reads number balanceOf(address owner) {
14 return balances[owner];
15 }
16
17 writes truth transfer(address recipient, number amount) {
18 number held = balances[caller];
19 require held >= amount, "insufficient funds";
20
21 balances[caller] = held - amount;
22 balances[recipient] = balances[recipient] + amount;
23 emit Transfer(caller, recipient, amount);
24 return yes;
25 }
26}1// Equivalent Solidity (.sol)
2// SPDX-License-Identifier: MIT
3pragma solidity ^0.8.20;
4
5contract TokenVault {
6 uint256 public totalSupply;
7 mapping(address => uint256) public balances;
8
9 event Transfer(address indexed from, address indexed to, uint256 amount);
10
11 constructor() {
12 totalSupply = 1000000;
13 balances[msg.sender] = 1000000;
14 }
15
16 function balanceOf(address owner) external view returns (uint256) {
17 return balances[owner];
18 }
19
20 function transfer(address recipient, uint256 amount) external returns (bool) {
21 uint256 held = balances[msg.sender];
22 require(held >= amount, "insufficient funds");
23
24 balances[msg.sender] = held - amount;
25 balances[recipient] = balances[recipient] + amount;
26 emit Transfer(msg.sender, recipient, amount);
27 return true;
28 }
29}Every Quorlin function opens with reads or writes; Solidity spreads the same information across external, view, and nothing-at-all. The compiler proves a reads function cannot write storage.
number and truth with yes/no instead of uint256 and bool with true/false. Same ABI underneath (uint256, bool) — a different surface for conditions people read carefully.
caller, not caller() and not msg.sender. Builtins take no parentheses because there is nothing to invoke.
map<address, number> instead of mapping(address => uint256), with one level of nesting allowed.
require held >= amount, "reason" instead of require(held >= amount, "reason"). A keyword cannot be shadowed by a local definition.
constructor { ... } instead of constructor() { ... }. It has no name and no arguments, so nothing can call it twice.
What the Quorlin version compiles to — KVM register disassembly
; Disassembled Kortana KVM Register Bytecode
.module TokenVault
.registers 32
.header magic=0x4B564D00 version=1 instructions=14
0000: LOAD_CALLER r1 ; caller address -> r1
0004: CONST_U256 r2, 0x0F4240 ; 1,000,000 -> r2
0008: STORE_SLOT 0x00, r2 ; totalSupply = 1000000
000C: MAP_STORE 0x01, r1, r2 ; balances[caller] = 1000000
; writes truth transfer(address recipient, number amount)
0010: LOAD_ARG r3, 0 ; recipient address
0014: LOAD_ARG r4, 1 ; amount
0018: MAP_LOAD r5, 0x01, r1 ; balances[caller] -> r5
001C: CMP_GTE r6, r5, r4 ; held >= amount ?
0020: REQ_TRUE r6, 0x00 ; require r6, "insufficient funds"
0024: SUB_U256 r7, r5, r4 ; r7 = held - amount
0028: MAP_STORE 0x01, r1, r7 ; balances[caller] = r7
002C: MAP_LOAD r8, 0x01, r3 ; balances[recipient] -> r8
0030: ADD_U256 r9, r8, r4 ; r9 = held + amount
0034: MAP_STORE 0x01, r3, r9 ; balances[recipient] = r9
0038: EMIT_EVENT 0x00, r1, r3, r4 ; emit Transfer(r1, r3, r4)
003C: RET_VAL 0x01 ; return yesEngineered 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.