Reference

1. Toolchain

The entire toolchain is two words. Write a Main function, compile, run.

// hello.sk
func Main() {
    out("hello, world")
}

$ skeet -c hello.sk
aced headshot 'hello.exe' hitchance 62%

$ ./hello.exe
hello, world

• Compile: skeet -c program.sk → produces program.exe in the same folder.
• Entry point: every program needs func Main().
• No build system, no package manager. The .exe is self-contained — copy it to any Windows machine, it runs.
• Tree-shaking: only the stdlib functions you actually call end up in the executable.

2. Language reference

2.1 Basic rules

• One statement per line. Multiple statements on one line are only allowed inside { } (separated by line breaks).
• Comments: // to end of line.
• Entry point: func Main() { ... }.
• C-family form with curly braces for blocks.

// this is a comment
func Main() {
    out("start")      // one statement
    out("end")         // another one
}

2.2 Functions

func name(int a, int b) {
    return a + b
}

• Declared with func, parameters with type and name.
• return expression returns a value.
• Implicit return 0: a function that falls through without return automatically yields 0 — void-style functions don't need a trailing return.
• Call: name(1, 2).
• Structs are allowed as parameters (they pass the address).

2.3 Types

Variable types (local variables & parameters):

int	64-bit integer (also serves as pointer/address)
float	32-bit floating point
double	64-bit floating point
string	pointer to null-terminated bytes
bool	truth value (true / false)
ptr	pointer (in struct fields)
int[]	array of 64-bit values (stack array)

Struct field types:

i8	1 byte
i16	2 bytes
i32	4 bytes
i64	8 bytes
f32	4 bytes (float)
f64	8 bytes (double)
ptr	8 bytes (pointer)
char[N]	N bytes (fixed character buffer)
bytes[N]	N bytes (fixed byte buffer)

2.4 Variables

int    n = 42
float  f = 3.5
double d = 7.25
string s = "skeet"
bool   b = true
int[]  a = [10, 20, 30]

• Declaration is Type name = value.
• Assignment to an existing variable: name = value.

2.5 Literals

Decimal integer	42
Hex integer	0xFF8A3D
Floating point	3.5, 7.25
String	"hello"
Boolean	true, false
Array	[10, 20, 30]

2.6 Operators

Arithmetic: + - * / %

int r = a + b * 2
int m = x % 4

Bitwise: & | ^ ~ << >>

int masked = flags & 0xF
int shifted = value << 3
int inverted = ~bits

Comparison: == != < <= > >= — yield 1 (true) or 0 (false).

Logical: && || !

if (a > 0 && b < 10) { ... }
if (!done) { ... }

Compound assignment: += -= *= /= %= &= |= ^= <<= >>=

x += 5
score *= 2
mask &= 0xFF

Increment / decrement: ++ --

i++
count--

Unary: -x (negation), +x, ~x (bit invert), !x (logical not)

Memory operators: &x (address of), *p (dereference)

2.7 Truthy conditions

Conditions treat any nonzero value as "true". Boolean flags read naturally because of it:

if (menuOpen) { ... }        // instead of menuOpen == 1
if (!dragging) { ... }       // instead of dragging == 0
if (count && ready) { ... }

2.8 Control flow

if / else if / else:

if (hp <= 0) {
    dead = 1
} else if (hp < 25) {
    warn = 1
} else {
    warn = 0
}

while:

while (frame.isOpen()) {
    render()
}

for:

for (int i = 0; i < n; i++) {
    out(i)
}

break / continue:

for (int i = 0; i < n; i++) {
    if (skip(i)) { continue }
    if (done)    { break }
}

return: return expression — or implicit return 0 on fallthrough.

2.9 Pointers & memory

int buf = alloc(256)     // reserve 256 bytes

// buf[i] is char*-style byte access:
buf[0] = 72              // same as poke8(buf+0, 72)
int c = buf[i]           // same as peek8(buf+i)
int p = &buf[2]          // address of the element (buf+2)

// wider access via peek/poke:
poke32(buf, 0xDEAD)      // write 32 bits
int v = peek32(buf)      // read 32 bits

free(buf)                // release memory

• buf[i] on a scalar pointer is byte-wise (like C char*) — values get truncated to 1 byte.
• int[] arrays (e.g. int[] a = [1,2,3]), by contrast, are 8-byte indexed.
• Use the peek/poke family for 16/32/64-bit access.

2.10 Structs

Definition (must come before first use):

struct Player {
    i32 health; i32 mana
    f32 posX;   f32 posY
    char name[32]
}

• Fields separated by ; or line breaks, several per line allowed.
• Natural C alignment.

Usage:

Player p = alloc(sizeof(Player))
p.health = 9999          // field access with .
out(p.posX)

• A struct variable holds an address; x.field lowers to peek/poke at base + offset.
• sizeof(Player) is a compile-time constant with the struct size in bytes.
• Structs work as function parameters (the address gets passed).

2.11 Arrays

int[] a = [10, 20, 30]
out(a[0])                // 10
a[1] = 99

• int[] arrays are stack arrays with 8-byte elements.
• Access and assignment via a[index].

2.12 Modules

Split across multiple files with #use:

// main.sk
#use [util.sk] as u

func Main() {
    out(u.helper(7))     // function from util.sk, via alias u
}

// util.sk
func helper(int n) { return n * n }

#use [file.sk] as alias binds a module; its functions are called via alias.function(...).

2.13 The #admin directive

#admin

func Main() { ... }

Embeds a requireAdministrator UAC manifest into the PE, so the program launches with admin rights (needed for accessing other processes without permission errors).

3. Builtins

Built-in functions that lower directly to machine code and Windows API calls, usable without the stdlib. Argument order and return values come straight from the compiler source.

3.1 Console & local memory

3.2 Remote process: handle & raw memory

3.3 Remote process: typed reads/writes

Base-plus-offset workflow. Reads return 0 on failure; integer reads zero-extend, except readIntS.

3.4 Remote process: allocation & protection

3.5 Threads & injected code

3.6 Toolhelp snapshots

Get the enumeration buffer yourself via alloc() and set its dwSize field (PROCESSENTRY32 = 304, MODULEENTRY32 = 568, THREADENTRY32 = 28).

3.7 Own process & system

3.8 Input & window

3.9 File I/O

3.10 Clipboard & global memory

3.11 Process launch

4. Standard library

std.sk — 44 functions, bundled with the compiler, callable unqualified (a function you define with the same name takes priority). Only functions you actually use end up in the executable.

4.1 Numbers

4.2 Strings (null-terminated, byte-wise)

4.3 Processes & modules

4.4 Pointer chains

Cheat Engine convention: the last offset is added to the resolved address.

4.5 Signature scanning (AOB with wildcards)

4.6 Value scanning (Cheat Engine workflow)

4.7 Byte patching & injection

4.8 Threads: suspend / resume a process

4.9 UI: bitmap font, rectangles

The framebuffer fb is a 32bpp buffer of width fbW; colors are 0xRRGGBB.

4.10 Clipboard

4.11 Directory entries (WIN32_FIND_DATAA)

4.12 External process

5. GUI toolkit

Four native Win32 objects plus a software framebuffer you draw into by hand and push to the screen via blit. Each object's value is its Win32 HWND.

5.1 SFrame — a regular window

Constructor: new SFrame("Title") — one argument, the window title. Position CW_USEDEFAULT, initial size 800×600, style WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN.

5.2 SButton — a click button

Constructor: new SButton(frame, "Text", x, y, width, height) — parent SFrame, label, x, y, width, height. Style WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_PUSHBUTTON. Max 31 buttons per program.

5.3 SComboBox — a dropdown list

Constructor: new SComboBox(frame, x, y, width, height) — parent SFrame, x, y, width, height. height is the total height including the expanded list (Win32 semantics). Style CBS_DROPDOWNLIST.

5.4 SOverlay — a transparent overlay

Constructor: new SOverlay(width, height) — creates a borderless, always-on-top, click-through WS_POPUP window at (0,0) (WS_EX_LAYERED|WS_EX_TRANSPARENT|WS_EX_TOPMOST) with black as the color key: pure-black pixels (0x000000) are transparent. The basis for ESP/game overlays.

Methods (shares HWND handling with SFrame):

6. The self-hosted IDE

skeet_ide.sk — a complete development environment, written entirely in 893 lines of skeet and compiled to a native .exe:

• File tree on the left with expandable directories, right-click menu (new file, rename, delete).
• Multiple tabs for open files, dynamically sized and scrollable.
• Editor with syntax highlighting, cursor, text editing (typing, Enter, Backspace, Tab), horizontal & vertical scrolling via sliders.
• Compiler output console at the bottom.
• Compile/Run buttons and a movable project.skobj panel (project definition with entry point and dependencies).

It uses the same software renderer (framebuffer + blit) and the same GUI/file builtins as any other skeet program — proof that the language carries its own weight.

7. Roadmap

Three tiers: what ships today, what's actively being built, and the horizon.

Shipped

• Native x64 PE backend — direct machine-code emission, no VM, no external linker, no C runtime.
• Full type & operator set — int / float / double / string / bool / ptr, int[] arrays, structs with C layout, the complete arithmetic/bitwise/logical/compound-assignment operator set, ++/--.
• Readable low-level access — buf[i] byte indexing, &buf[i], else if, truthy conditions, sizeof, implicit return 0.
• Modules & tree-shaken stdlib — #use ... as, the #admin UAC manifest, a 44-function std.sk that only compiles in what's actually called.
• ~80 compiler builtins — local & remote-process memory, threads, snapshots, file I/O, input, windowing, clipboard, process launch.
• GUI toolkit — SFrame, SButton, SComboBox, SOverlay, plus a software framebuffer renderer.
• Game-hacking suite — value scanning (first/next/exact/cmp/val), AOB scanning with wildcards, pointer chains, code & DLL injection, value freezing, process suspend/resume.
• Self-hosted IDE — file tree, tabs, syntax-highlighted editor, scrollbars, compile/run — 893 lines of skeet.

In progress

• String == by content — today == on strings compares pointers; strEq() is the workaround. Teaching the evaluator a string type so if (name == "foo.sk") just works.
• Struct field indexing — ctx.buf[i] should lower directly instead of needing a local pointer first.
• Richer graphics primitives — drawLine, circles, and alpha blending in the software renderer.

Horizon

• Enums & constants — named alternatives to magic-number flags.
• String formatting / interpolation — building messages without hand-rolled strAppend plus number conversion.
• for-each & array-of-structs sugar — iterating collections and typed blocks without manual index math.
• Language server + debugger in the IDE — diagnostics while typing; stepping through a running .exe.
• Self-hosting compiler — the endgame: skeet compiles skeet, the Java frontend retires.

All signatures and semantics come directly from the compiler source and standard library. Roadmap tiers reflect current status; scope and order can change.