Language Basics

SPIDER’s syntax is intentionally minimal. If you’ve used Rust, C, or JavaScript, the structure will feel familiar. Blocks use braces, statements end with semicolons, and functions use a clean func keyword.

Comments

SPIDER supports the following comment styles:

// Single-line comment

/* 
   Multi-line comment
*/

""" 
Multi-line string literal (not a comment).
Use this when you want to embed large blocks of text.
"""

Variables

Variables in SPIDER are declared with let. Values are immutable by default unless marked mut.

Immutable Variable

let x = 10;

Mutable Variable

let mut counter = 0;
counter = counter + 1;

Type Inference

Types are inferred unless explicitly stated.

let a = 42;          // int
let b = 3.14;        // float
let c = "hello";     // str

Explicit Types

let x: int = 10;
let y: float = 2.5;
let id: uint = 1000;

Types

SPIDER includes a set of core built-in types, as well as system-oriented ones for bytes, pointers, and results.

Literals

42              // int
3.14            // float
true            // bool
"hello"         // string
b"ABC"          // byte literal
"""big text"""  // multi-line string

Operators

Control Flow

If / Else

if x > 10 {
    println("large");
} else {
    println("small");
}

While Loop

let mut i = 0;

while i < 5 {
    println(i);
    i += 1;
}

For Loop

for n in 0..5 {
    println(n);
}

Loop + Break

loop {
    println("running");
    break;
}

Match

match code {
    200 => println("OK"),
    404 => println("Not found"),
    _   => println("Unknown"),
}

Functions

Functions are declared using func. Parameters may be typed or inferred.

Basic Function

func greet(name: str) {
    println("Hello, " + name);
}

Function With Return Value

func add(a: int, b: int) -> int {
    return a + b;
}

Implicit Return

The final expression is returned automatically if return is omitted.

func square(n: int) -> int {
    n * n
}

Void Function

func log_message(msg: str) -> void {
    println(msg);
}

Calling a Function

let result = add(10, 20);
println(result);

Structs

Structs define custom data types with named fields. They are lightweight and ideal for representing structured data.

Defining a Struct

struct User {
    id: int,
    name: str,
    active: bool,
}

Creating an Instance

let u = User { 
    id: 1, 
    name: "Alice",
    active: true,
};

Accessing Fields

println(u.name);
println(u.id);

Mutating Fields

let mut u = User { id: 1, name: "Alice", active: true };
u.active = false;

Enums

Enums allow you to define a type that can be one of several variants.

Basic Enum

enum Status {
    Online,
    Offline,
    Busy,
}

Enum with Data

enum Message {
    Text(str),
    Ping(int),
    Error(str),
}

Creating Enum Values

let s = Status::Online;

let m = Message::Text("hello");

Pattern Matching

match allows exhaustive branching based on values, including enums.

Matching an Enum

match m {
    Message::Text(t) => println("text: " + t),
    Message::Ping(n) => println("ping: " + n),
    Message::Error(e) => println("error: " + e),
}

Matching Primitive Values

match code {
    200 => println("OK"),
    403 => println("Forbidden"),
    404 => println("Not Found"),
    _   => println("Unknown"),
}

Arrays

Arrays are dynamic and can grow or shrink.

Creating an Array

let nums = [1, 2, 3, 4, 5];

Indexing

println(nums[0]);     // 1
println(nums[3]);     // 4

Appending

nums.push(6);

Iteration

for n in nums {
    println(n);
}

Maps

Maps (hash tables) store key/value pairs.

Create a Map

let m = map_new();

Insert Values

map_set(m, "name", "Alice");
map_set(m, "score", 42);

Retrieve Values

let n = map_get(m, "name");
println(n);

Map Contains

if map_has(m, "score") {
    println("found score");
}

Error Handling

SPIDER uses a Result type, containing either Ok(value) or Err(error).

Returning a Result

func divide(a: int, b: int) -> Result {
    if b == 0 {
        return Err("divide by zero");
    }
    return Ok(a / b);
}

Using Match for Error Handling

let res = divide(10, 2);

match res {
    Ok(v)  => println("value: " + v),
    Err(e) => println("error: " + e),
}

Automatic Unwrap

You can unwrap a Result when you're sure it won't fail.

let value = unwrap(divide(10, 2));

If the function returns Err, the program terminates with an error.

Option-Like Behavior

SPIDER does not have a formal Option type but treats null-style values via Err or map_has patterns.

let m = map_new();
map_set(m, "x", 10);

if map_has(m, "x") {
    let value = map_get(m, "x");
    println(value);
}

TCP Networking

SPIDER offers a simple but powerful TCP API for client-side communication. Each TCP connection is represented internally by a socket handle.

tcp_connect(host: str, port: int) -> Result

Opens a TCP connection and returns a socket handle.

let sock = unwrap(tcp_connect("example.com", 80));

tcp_send(socket, data: str or bytes) -> int

Sends data over the TCP connection.

tcp_send(sock, "GET / HTTP/1.1\r\n\r\n");

tcp_recv(socket, max_bytes: int) -> bytes

let response = tcp_recv(sock, 4096);
println(response);

tcp_close(socket)

tcp_close(sock);

Example: Simple HTTP Request

let sock = unwrap(tcp_connect("example.com", 80));

tcp_send(sock, 
    "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
);

let res = tcp_recv(sock, 8192);
println(res);

tcp_close(sock);

UDP Networking

UDP is connectionless, meaning packets are sent without establishing a session.

udp_send(host: str, port: int, data: bytes or str)

udp_send("8.8.8.8", 53, "payload");

udp_recv(port: int, max_bytes: int) -> bytes

let incoming = udp_recv(9000, 1024);
println(incoming);

Broadcast Example

udp_send("255.255.255.255", 9999, "DISCOVER");

DNS Lookup

dns_lookup(domain: str) -> str

let ip = dns_lookup("google.com");
println(ip);

Returns the first resolved IPv4 address.

HTTP / HTTPS

SPIDER includes built-in HTTPS with automatic TLS.

https_get(url: str) -> str

let body = https_get("https://httpbin.org/get");
println(body);

https_post(url: str, data: str or bytes) -> str

let resp = https_post(
    "https://httpbin.org/post",
    "username=admin&password=1234"
);

https_post_json(url: str, map_object) -> str

let body = https_post_json(
    "https://api.site.com/update",
    { "score": 42, "user": "test" }
);

Port Scanning

scan_port(ip: str, port: int) -> bool

Returns true if port is open, otherwise false.

if scan_port("192.168.1.1", 80) {
    println("Port open");
}

Example: Scan a Range

for p in 1..1024 {
    if scan_port("192.168.1.1", p) {
        println("Open: " + p);
    }
}

Packet API

SPIDER v3 provides minimal raw packet functionality (intended for learning and non-destructive research).

packet_create(proto: str, fields: map) -> bytes

let ip_header = {
    "src": "192.168.0.2",
    "dst": "192.168.0.3",
    "ttl": 64,
};

let pkt = packet_create("ipv4", ip_header);

packet_send(interface: str, bytes)

packet_send("eth0", pkt);

Example: Custom Packet

let hdr = {
    "src": "10.0.0.2",
    "dst": "10.0.0.10",
    "flags": 2
};

let pkt = packet_create("tcp", hdr);
packet_send("eth0", pkt);

Cryptography

SPIDER includes a full cryptographic toolkit built directly into the runtime. All functions are pure, stateless, and safe to call repeatedly.

Hash Functions

Supported algorithms:

• MD5
• SHA-256
• SHA-512

md5(data: str) -> str

let h = md5("hello");
println(h);

sha256(data: str) -> str

let h = sha256("password123");
println(h);

sha512(data: str) -> str

let h = sha512("top_secret");
println(h);

Base64 Encoding / Decoding

encode_base64(data: bytes or str) -> str

let out = encode_base64("Hello!");
println(out);

decode_base64(text: str) -> bytes

let bytes = decode_base64(out);
println(bytes);

XOR Cipher

Symmetric reversible cipher. Recommended for obfuscation, NOT strong encryption.

xor_cipher(data: str or bytes, key: str) -> bytes

let enc = xor_cipher("Secret Message", "KEY123");
let dec = xor_cipher(enc, "KEY123");  // reversible
println(dec);

AES-256 Encryption

SPIDER v3 implements AES-256 in two modes:

• CBC (simple, widely used)
• GCM (authenticated encryption, preferred)

AES-256-CBC

aes256_cbc_encrypt(data: bytes, key: bytes, iv: bytes) -> bytes

aes256_cbc_decrypt(data: bytes, key: bytes, iv: bytes) -> bytes

let key = random_bytes(32);
let iv  = random_bytes(16);

let ciphertext = aes256_cbc_encrypt("HELLO", key, iv);
let plaintext  = aes256_cbc_decrypt(ciphertext, key, iv);

println(plaintext);

AES-256-GCM (Authenticated)

aes256_gcm_encrypt(data: bytes, key: bytes, nonce: bytes) -> map

• ciphertext
• tag (authentication tag)

aes256_gcm_decrypt(ciphertext, key, nonce, tag) -> bytes

let key   = random_bytes(32);
let nonce = random_bytes(12);

let enc = aes256_gcm_encrypt("HELLO", key, nonce);

let dec = aes256_gcm_decrypt(
    enc["ciphertext"],
    key,
    nonce,
    enc["tag"]
);

println(dec);

If authentication fails, decrypt throws a runtime error.

Key Derivation (PBKDF2-like)

Used to turn passwords into real cryptographic keys.

kdf_derive(password: str, salt: bytes, rounds: int, key_len: int) -> bytes

let salt = random_bytes(16);
let key  = kdf_derive("mypassword", salt, 600000, 32);

println(encode_base64(key));

Random Generation

random_bytes(len: int) -> bytes

let b = random_bytes(32);
println(b);

random_int(min: int, max: int) -> int

let n = random_int(1, 10);
println(n);

UUID Generation

generate_uuid() -> str

let id = generate_uuid();
println(id);   // "bd19a670-f912-4c6d-a810-98b5c2e012fe"

File System Operations

The SPIDER standard library includes full cross-platform file & directory support. All file operations return booleans or throw errors on failure.

Reading Files

read_file(path: str) -> str

let content = read_file("data.txt");
println(content);

read_bytes(path: str) -> bytes

let binary = read_bytes("image.bin");
println(binary);

Writing Files

write_file(path: str, data: str or bytes) -> bool

write_file("output.txt", "Hello World!");

append_file(path: str, data: str or bytes) -> bool

append_file("log.txt", "New Entry\n");

create_file(path: str) -> bool

create_file("empty.txt");

File Operations

file_exists(path: str) -> bool

if file_exists("config.sp") {
    println("config exists");
}

delete_file(path: str) -> bool

delete_file("temp.bin");

copy_file(src: str, dst: str) -> bool

copy_file("a.txt", "b.txt");

move_file(src: str, dst: str) -> bool

move_file("old.txt", "archive/old.txt");

get_file_size(path: str) -> int

let size = get_file_size("video.mp4");
println(format("Size: {} bytes", size));

get_file_modified(path: str) -> int

let ts = get_file_modified("notes.txt");
println(ts);

get_file_created(path: str) -> int

let ts = get_file_created("notes.txt");
println(ts);

Directory Operations

list_dir(path: str) -> list

let items = list_dir(".");
for item in items {
    println(item);
}

create_dir(path: str) -> bool

create_dir("logs");

delete_dir(path: str) -> bool

delete_dir("old_data");

dir_exists(path: str) -> bool

if dir_exists("src") {
    println("src folder present");
}

current_dir() -> str

println(current_dir());

change_dir(path: str) -> bool

change_dir("docs");

Path Utilities

path_join(a, b, ...)

let p = path_join("folder", "sub", "file.txt");
println(p);

path_basename(path: str) -> str

println(path_basename("/usr/local/bin/file"));

path_dirname(path: str) -> str

println(path_dirname("/usr/local/bin/file"));

path_extension(path: str) -> str

println(path_extension("photo.jpeg"));  // ".jpeg"

path_normalize(path: str) -> str

let cleaned = path_normalize("/home/user/../docs//file.txt");
println(cleaned);

is_absolute(path: str) -> bool

println(is_absolute("/usr/bin"));

is_relative(path: str) -> bool

println(is_relative("src/main.sp"));

Examples

Example: Log Rotator

if file_exists("log.txt") {
    let ts = get_timestamp();
    move_file("log.txt", format("logs/log_{}.txt", ts));
}

write_file("log.txt", "New session\n");

Example: Directory Scanner

let items = list_dir(".");
for x in items {
    if file_exists(x) {
        println(format("FILE: {}", x));
    } else {
        println(format("DIR:  {}", x));
    }
}

Example: Save Binary Data

let raw = random_bytes(64);
write_file("key.bin", raw);
println("saved 64 bytes");

Control Flow

SPIDER provides simple but powerful flow constructs inspired by C, Rust, and Python. All keywords shown below are built into the parser and compiler.

If / Else

Syntax

if condition {
    // block
} else if condition {
    // block
} else {
    // block
}

Example

let age = 17;

if age >= 18 {
    println("Adult");
} else if age >= 13 {
    println("Teen");
} else {
    println("Child");
}

Boolean Expressions

Supported operators:

• == equal
• != not equal
• >, <, >=, <=
• && logical AND
• || logical OR
• ! logical NOT

if x == 10 && y != 5 {
    println("Match!");
}

Pattern Matching

match is SPIDER’s powerful branching tool. It behaves similarly to Rust’s match or a more strict switch.

Syntax

match value {
    case pattern1 {
        ...
    }
    case pattern2 {
        ...
    }
    default {
        ...
    }
}

Supported patterns:

• Literal match (`1`, `"yes"`, etc.)
• Multiple values (`case 1,2,3`)
• Ranges (`case 1..5`)
• Wildcard (`_`)

Example

let x = 4;

match x {
    case 1 {
        println("one");
    }
    case 2,3 {
        println("two or three");
    }
    case 4..10 {
        println("between 4 and 10");
    }
    default {
        println("something else");
    }
}

Looping

• loop (infinite)
• while
• for-in loops

loop {} (infinite)

loop {
    println("Running");
}

break keyword

loop {
    break;
}

continue keyword

for i in [1,2,3,4,5] {
    if i == 3 {
        continue;
    }
    println(i);
}

while condition {}

let x = 0;

while x < 5 {
    println(x);
    x = x + 1;
}

for value in collection {}

SPIDER’s for-in works on arrays, strings, and maps.

let arr = [10, 20, 30];

for item in arr {
    println(item);
}

Iterating maps

let m = map_new();
m = map_set(m, "a", 1);
m = map_set(m, "b", 2);

for key in map_keys(m) {
    println(format("{} = {}", key, m[key]));
}

Error Handling

SPIDER includes structured error handling using try/catch blocks.

Basic Syntax

try {
    // Code that might fail
} catch err {
    println(err);
}

Example

try {
    let data = read_file("missing.txt");
    println(data);
} catch e {
    println("File error: " + e);
}

panic(message: str)

Panic immediately stops execution and prints an error message.

panic("Critical failure!");

throw(message: str)

Throw a runtime error that can be caught by a surrounding catch block.

func div(a: int, b: int) -> int {
    if b == 0 {
        throw("divide by zero");
    }
    return a / b;
}

Runtime Exceptions

The following SPIDER API calls naturally generate catchable errors:

• File operations (reading/writing) on invalid paths
• Network requests failing (connection refused, SSL error, timeout)
• JSON parse errors
• AES/GCM authentication failure
• Index out of bounds
• Type mismatch

Example catching builtin exception

try {
    let arr = [1,2,3];
    println(arr[10]);  // invalid index
} catch err {
    println("Caught: " + err);
}

Examples

Example: Countdown Loop

let x = 5;

while x > 0 {
    println(x);
    x = x - 1;
}

println("Done!");

Example: Menu System

loop {
    println("1. Hash");
    println("2. Exit");

    let choice = input("> ");

    match choice {
        case "1" {
            let text = input("Text: ");
            println(sha256(text));
        }
        case "2" {
            break;
        }
        default {
            println("Invalid");
        }
    }
}

Example: Exception-safe File Reader

func safe_read(path: str) -> str {
    try {
        return read_file(path);
    } catch err {
        return "ERR: " + err;
    }
}

println(safe_read("maybe.txt"));

Functions

Functions are a core part of SPIDER. SPIDER supports:

• Typed & untyped parameters
• Return types (->)
• Default values
• Recursion
• Closures & lambdas
• Exported functions (export)
• Dependency-bound functions (dep)
• Async functions (async / await)
• Unsafe execution blocks

Basic Function

func greet() {
    println("Hello!");
}

greet();

Function With Parameters

func add(a: int, b: int) -> int {
    return a + b;
}

println(add(4, 7));   // 11

Optional Type Annotations

SPIDER allows untyped params (dynamic dispatch):

func shout(text) {
    println(upper(text));
}

Default Parameter Values

func welcome(name: str = "guest") {
    println("Welcome " + name);
}

welcome();           // Welcome guest
welcome("KCdev");    // Welcome KCdev

Returning Values

SPIDER requires an explicit return when using -> type.

func cube(x: int) -> int {
    return x * x * x;
}

func check(n: int) -> str {
    if n == 0 {
        return "zero";
    }
    return "non-zero";
}

Void Return Type (unit)

func log(msg: str) -> void {
    println(msg);
}

export keyword

Used by module systems and the compiler to allow external usage.

export func hash_user(name: str) -> str {
    return sha256(name);
}

dep "crypto.spdi";

println(hash_user("admin"));

dep keyword

Imports another SPIDER script.

dep "math.spdi";
dep "utils/crypto.spdi";

println(square(9));

Recursive Functions

func factorial(n: int) -> int {
    if n <= 1 {
        return 1;
    }
    return n * factorial(n - 1);
}

println(factorial(5));   // 120

Tail recursion

func sum(n: int, acc: int = 0) -> int {
    if n == 0 {
        return acc;
    }
    return sum(n - 1, acc + n);
}

Closures (Anonymous Functions)

let double = func(x: int) -> int {
    return x * 2;
};

println(double(10));     // 20

Lambdas (Short Syntax)

let square = |x| x * x;

println(square(6));  // 36

func apply_twice(f, value) {
    return f(f(value));
}

println(apply_twice(|x| x + 1, 5));  // 7

Built-in higher-order usage

let nums = [1,2,3,4];

let doubled = array_map(nums, |x| x * 2);

println(doubled);   // [2,4,6,8]

Async Functions

SPIDER supports asynchronous functions for networking, timers, and concurrent operations.

async func fetch(url: str) -> str {
    return https_get(url);
}

func main() -> int {
    let html = await fetch("https://example.com");
    println(html);
    return 0;
}

Parallel async example

async func get_a() -> str {
    sleep(200);
    return "A";
}

async func get_b() -> str {
    sleep(100);
    return "B";
}

func main() -> int {
    let a = await get_a();
    let b = await get_b();

    println(a + " " + b);
    return 0;
}

Unsafe Blocks

unsafe {
    let ptr = alloc_bytes(16);
    write_ptr(ptr, 0x41);
    free_ptr(ptr);
}

unsafe {
    let buf = alloc_bytes(1024);
    fill_bytes(buf, 0xFF);
}

unsafe func zero_mem(buf: ptr, size: int) {
    memset(buf, 0, size);
}

Why unsafe?

• Bypasses all safety checks
• Allows direct pointer arithmetic
• Allows host-level memory access

Function Overloading

func show(x: int) {
    println("int");
}

func show(x: str) {
    println("string");
}

show(10);     // int
show("hi");   // string

Complete Examples

Example 1 — Hash Wrapper

export func secure_hash(data: str) -> str {
    return sha512(data);
}

Example 2 — Functional Style Map

func filter_even(arr) {
    return array_filter(arr, |x| x % 2 == 0);
}

println(filter_even([1,2,3,4,5,6]));  

Example 3 — Async Web Downloader

async func download(url: str) -> void {
    let html = await https_get(url);
    write_file("page.html", html);
}

func main() -> int {
    await download("https://kernelcore.dev");
    return 0;
}

Example 4 — Unsafe Memory Viewer

unsafe func dump(ptr: ptr, size: int) {
    for i in 0..size {
        println(hex(read_ptr(ptr + i)));
    }
}

Example 5 — Recursion + Pattern Matching

func describe(n: int) -> str {
    match n {
        case 0 { return "zero"; }
        case 1 { return "one"; }
        case 2..5 { return "small"; }
        default { return "large"; }
    }
}

Structs

Structs are custom data types that store fields. They behave like lightweight objects with optional attached methods.

Basic Struct Definition

struct User {
    name: str,
    age: int,
    admin: bool
}

Creating Struct Instances

let u = User {
    name: "KCdev",
    age: 16,
    admin: true
};

Accessing & Modifying Fields

println(u.name);      // KCdev
println(u.age);       // 16

u.age = 17;
println(u.age);       // 17

Struct Constructor Function

Since SPIDER doesn’t automatically generate constructor functions, you usually write one manually:

func new_user(name: str, age: int) -> User {
    return User { name: name, age: age, admin: false };
}

let u = new_user("bob", 18);

Structs With Default Values

struct Config {
    host: str = "127.0.0.1",
    port: int = 8080,
    https: bool = false
}

let cfg = Config {};
println(cfg.port);    // 8080

Inline Struct Literal Use

println(User { name: "Alice", age: 20, admin: false }.name);

Methods

SPIDER supports instance methods and static methods (associated functions). Methods are defined using:

func StructName.methodName(self, ...)

Instance Methods

struct Point {
    x: int,
    y: int
}

func Point.move(self, dx: int, dy: int) {
    self.x = self.x + dx;
    self.y = self.y + dy;
}

let p = Point { x: 2, y: 5 };
p.move(3, -2);

println(p.x);   // 5
println(p.y);   // 3

Methods With Return Types

func Point.len(self) -> float {
    return sqrt((self.x*self.x) + (self.y*self.y));
}

Associated Functions (Static Methods)

func Point.origin() -> Point {
    return Point { x: 0, y: 0 };
}

let p = Point.origin();

Enums

SPIDER enums allow variants with optional data. Similar to Rust enums.

Basic Enum

enum Status {
    Online,
    Offline,
    Busy
}

Enum With Data

enum Response {
    Ok(str),
    Err(str)
}

Using Enums

let s = Status.Online;

match s {
    case Online {
        println("User online");
    }
    case Offline {
        println("User offline");
    }
    case Busy {
        println("User busy");
    }
}

Enum With Data Example

let r = Response.Ok("Success");

match r {
    case Ok(msg) {
        println("OK: " + msg);
    }
    case Err(e) {
        println("ERROR: " + e);
    }
}

Result, Ok, Err

Result is built into the lexer: Result, Ok, Err

Returning Result

func read_safe(path: str) -> Result {
    try {
        let data = read_file(path);
        return Ok(data);
    } catch err {
        return Err(err);
    }
}

Using Result

let res = read_safe("config.json");

match res {
    case Ok(data) {
        println("Loaded!");
    }
    case Err(e) {
        println("Failed: " + e);
    }
}

Helper pattern

func divide(a: int, b: int) -> Result {
    if b == 0 {
        return Err("divide by zero");
    }
    return Ok(a / b);
}

Pattern Destructuring

SPIDER supports pattern binding inside match for structs and enums.

Destructuring Structs

struct User {
    name: str,
    age: int
}

let u = User { name: "Eve", age: 19 };

match u {
    case User { name, age } {
        println(name);
        println(age);
    }
}

Partial Struct Bind

match u {
    case User { name } {
        println(name);
    }
}

Destructuring Enums (Variants With Data)

enum Message {
    Text(str),
    Ping,
    Error(int, str)
}

let m = Message.Error(404, "Not Found");

match m {
    case Text(t) {
        println("msg: " + t);
    }
    case Ping {
        println("ping received");
    }
    case Error(code, msg) {
        println(format("ERR {}: {}", code, msg));
    }
}

Type System Overview

Collections

• array — dynamic list
• map — dictionary of key/value pairs

Custom Types

• struct
• enum
• Result

Type Inference

let a = 10;       // int
let b = 4.2;      // float
let c = "hi";     // str
let d = [1,2,3];  // array[int]

Type Mismatch Errors

let x = 10;
x = "hello";     // ERROR: cannot assign str to int

Explicit Casting

let x = to_float(10);
let n = to_int("42");

Complete Examples

Example 1: Struct + Method

struct Counter {
    val: int
}

func Counter.inc(self) {
    self.val = self.val + 1;
}

func main() -> int {
    let c = Counter { val: 0 };
    c.inc();
    println(c.val);
    return 0;
}

Example 2: Enum State Machine

enum State {
    Idle,
    Working(int),
    Error(str)
}

func describe(s: State) -> str {
    match s {
        case Idle { return "idle"; }
        case Working(x) { return format("working: {}", x); }
        case Error(e) { return "error: " + e; }
    }
}

Example 3: Result + Struct

struct Creds {
    user: str,
    pass: str
}

func load_creds(path: str) -> Result {
    try {
        let txt = read_file(path);
        let parts = split(txt, ":");
        return Ok(Creds { user: parts[0], pass: parts[1] });
    } catch err {
        return Err(err);
    }
}

Example 4: Struct With Embedded Enum

enum Mode {
    Debug,
    Release
}

struct BuildConfig {
    name: str,
    mode: Mode
}

let cfg = BuildConfig {
    name: "SPIDER",
    mode: Mode.Debug
};

SPIDER Memory Model

SPIDER uses a simple but powerful memory model designed for:

• High performance
• Zero-copy operations where possible
• Optional unsafe low-level access
• Predictable behavior for exploit/security tooling

Stack vs Heap

Value semantics

let a = 10;
let b = a;
b = 20;   // does NOT change a

let a = [1,2,3];
let b = a;
b.push(4);

println(a);   // [1,2,3,4]

clone()

let a = [1,2,3];
let b = clone(a);

b.push(99);
println(a); // [1,2,3]
println(b); // [1,2,3,99]

Refcounting Notes

Pointers

let x = 10;
let p: ptr = &x;

unsafe {
    println(*p);
}

let x = 5;
let p = &x;

unsafe {
    *p = 999;
}

println(x);    // 999

let p: ptr = ptr_from_uint(0x7fffdeadbeef);

unsafe {
    let q = p + 4;  // move forward 4 bytes
}

let p: ptr = null;

unsafe {
    let p = &x;
    *p = 1337;
}

let buf = bytes("AAAA");
let p = &buf[0];

unsafe {
    *p = 0x42;    // replace first byte with 'B'
}

let slice = bytes_from_ptr(p, len=16);

let buf = b"hello";
println(buf);        // [68, 65, 6C, 6C, 6F]

buf.push(0x41);

println(buf[0]);  // 0x68

let part = buf[0..2];

let s = to_string(buf);

let b = to_bytes("ABC");

let buf = alloc(64);

unsafe {
    let p = &buf[0];
    *p       = 0x48;   // mov rax, 1
    *(p + 1) = 0x31;
    *(p + 2) = 0xC0;
}

exec(buf);

func memscan(start: ptr, end: ptr, target: int) {
    unsafe {
        let p = start;
        while p < end {
            if *p == target {
                println(format("FOUND AT {}", ptr_to_uint(p)));
            }
            p = p + 1;
        }
    }
}

struct Header {
    id: uint,
    size: uint,
    flags: uint
}

let h = Header { id: 1, size: 40, flags: 0xFF };

unsafe {
    let p = &h;
    println(ptr_to_uint(p));
}

unsafe {
    let mem = alloc_raw(32);
    let p: ptr = mem;

    *(p+0) = 0x41;
    *(p+1) = 0x42;
    *(p+2) = 0x43;

    println(bytes_from_ptr(p, 3)); // ABC
}

let arr = [1,2,3];

unsafe {
    let p = &arr[0];
    *(p + 10) = 999;    // OOB write
}

let mem = alloc_raw(sizeof(Header));
let p = mem;

let h: Header = from_ptr(p);

unsafe {
    let fnptr: func() = from_ptr(0x401000);
    fnptr();
}

let ciphertext = encrypt("hello", b"supersecretkeysupersecretkey!!");
let plaintext  = decrypt(ciphertext, b"supersecretkeysupersecretkey!!");

let out = xor("HELLO", "KEY");
println(out);

println(hash("test"));

let e = base64_encode("spider");
println(e);
println(base64_decode(e));

let s = socket("tcp");
s.connect("127.0.0.1", 8080);
s.send("hello");
let r = s.recv(1024);
s.close();

let u = socket("udp");
u.send_to("hi", "8.8.8.8", 53);

let pkt = packet();
pkt.write_u8(0x41);
pkt.write_u16(80);
pkt.write_str("HTTP");
send_raw(pkt);

let data = http_get("https://example.com");
println(data);

let server = socket("tcp");
server.bind("0.0.0.0", 4444);
server.listen(10);

while true {
    let client = server.accept();
    client.send("connected\n");
}

scan("127.0.0.1", ports=[22,80,443]);

exploit("CVE-TEST-OVERFLOW", target="127.0.0.1");

let t = spawn(|| {
    println("Thread running");
});
t.join();

sleep(1000); // 1 second

let lock = mutex();

spawn(|| {
    lock.acquire();
    println("A");
    lock.release();
});

let a = atomic(0);
a.inc();
println(a.get());

let out = shell("whoami");
println(out);

let p = process("ping 8.8.8.8");
p.read_line();
p.kill();

let buf = alloc(64);

let p = alloc_raw(32);

unsafe {
    hook(0x401000, my_hook_ptr);
}

let mem = process_memory(1337);
let bytes = mem.read(0x7ffdf000, 64);

println(format_time(now()));

let key = random_bytes(32);

println(hex_encode(b"ABC"));
println(hex_decode("414243"));

dump(my_struct);

dep "path/to/module.sp";

// main.sp
dep "crypto.sp";
dep "utils/math.sp";

println(add(10, 20));
println(aes_encrypt("hi", KEY));

dep "a.sp";
dep "a.sp"; // ignored second time

// crypto.sp
export func aes_encrypt(data, key) {
    ...
}

dep "crypto.sp" as crypto;

crypto.aes_encrypt("data", key);

dep "utils";

export let PI = 3.141;

export func add(a,b) {
    return a+b;
}

export struct Vec2 {
    x: float,
    y: float
}

export from "math/base.sp";

dep "crypto";

dep "/home/user/scripts/exploit.sp";

// a.sp
dep "b.sp";
export func A() { println("A"); }

// b.sp
dep "a.sp";
export func B() { println("B"); }

// a.sp
dep "b.sp";
export func A() { B(); }   // ERROR: B not fully defined yet

// b.sp
dep "a.sp";
export func B() { A(); }

dep "crypto.sp";
dep "net.sp";
dep "utils/math.sp";

println(add(5, 5));
println(hash("hi"));
connect_and_scan("192.168.1.1");

dep "std/net" as net;
dep "std/crypto" as crypto;

let data = net.http_get("https://kernelcore.dev");
let h = crypto.hash(data);

println(h);

let m = module_info("crypto");

println(m.name);
println(m.exports); // list of exported symbols

export func encrypt_file(path, key) {
    let data = read_file(path);
    let enc = encrypt(data, key);
    write_file(path + ".enc", enc);
}

dep "crypto.sp";

encrypt_file("secrets.txt", b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");

export func scan_host(host) {
    for p in 1..1024 {
        if port_open(host, p) {
            println(format("{} open", p));
        }
    }
}

dep "scan.sp";

scan_host("127.0.0.1");

export struct User {
    id: int,
    name: str
}

dep "models/user.sp";

let u = User { id: 1, name: "KCdev" };
println(u.name);