Overview

Cob is a corn-themed hybrid language with Python-style, indentation-and-colon block structure. A program is a sequence of statements; blocks (currently only while — there is no if/else) are opened with a trailing : and their body is whatever's indented further than the header line.

set x = 5
while x > 0:
    pop("counting down")
    set x = x - 1
pop("liftoff")

Indentation is spaces only — tabs are a hard error.

The toolchain

Language reference

pop("text")

Writes text to stdout followed by a newline.

pop("hello")          # hello
pop("line one\nline two")

Supported escapes inside the string literal: \\, \", \n, \t.

set <name> = <expr>

Assigns a value to a variable, creating it if it doesn't exist yet. A value is either an integer or a string. Expressions support + - * / with standard precedence (*// bind tighter than +/-) on two integers; + also concatenates when either side is a string, converting the other side to text first.

set a = 2 + 3 * 4              # 14
set b = a - 1
set greeting = "count: " + a  # "count: 14"

while <condition>:

Loops while the condition is true. A bare expression is a truthiness test (nonzero); a comparison uses == != < > <= >=, and works the same way on two strings as it does on two integers. Loops nest to any depth and are capped at 10,000,000 iterations as a safety net against runaway/infinite programs.

while a != 0:
    pop("tick")
    set a = a - 1

shuck <library_name>

Loads <library_name>.cob (checking the current directory first, then cob_modules/<library_name>/<library_name>.cob — the layout farmer harvest installs into) and splices its statements in at that point, like a textual include. Circular imports and excessive nesting depth are rejected with a clear error.

shuck greeter
pop("back in the main program")

harvest(<bytes>) / trash(<variable>)

Low-level manual memory: harvest(n) is an expression that allocates n bytes and returns an opaque integer handle; trash(v) frees the handle held in v. Both require the --no-gc flag — a program that uses either without it is refused outright by both cob_interp and popcorn_comp, not silently ignored.

set p = harvest(64)
trash(p)

_MakeCache = False

If the literal first line of a .cob file is _MakeCache = False (whitespace/case-insensitive), the .strawberry fast-boot cache is disabled entirely for that file — neither read nor written.

_MakeCache = False
pop("always reparsed fresh")

Extensions 0.0.5

SQLite — sql_open / sql_exec / sql_query / sql_close

A thin binding onto SQLite's C API, one open database handle per call to sql_open().

set h = sql_open("scores.db")
set rc = sql_exec(h, "CREATE TABLE IF NOT EXISTS t (name TEXT)")
set rc = sql_exec(h, "INSERT INTO t VALUES ('cob')")
set name = sql_query(h, "SELECT name FROM t LIMIT 1")
pop("got: " + name)
set rc = sql_close(h)

_cobwindow — a native window, backed by raylib + raygui

A small, real (not simulated) desktop window, opened with shuck cobwindow first.

shuck cobwindow
set h = window_open("Cob Window Demo")
set rc = window_label(h, "Hello from Cob!")
set clicked = window_button(h, "OK")
set volume = window_slider(h, "Volume", 100)
set name = window_textbox(h, "Name")
set rc = window_wait(h, 5)
set rc = window_close(h)

Each widget is identified by its own label text, not a separate handle — the first window_button()/ window_slider()/window_textbox() call with a given label creates that widget, auto-stacked on screen below the window_label() text; every later call with the same label (and kind — a button and a slider can share a label without colliding) reads or updates that same widget. Declaring and reading happen in the same call, since Cob has no separate "declare once, poll every frame" mechanism:

• window_button()'s click flag resets on read, so a click is reported exactly once.
• window_slider() re-ranges (and clamps the current value into the new range) if called again with a different <max>.
• window_textbox() is always in an editable state — Cob has no click-to-focus concept to hook a toggle to.

Tcl/Tk — tcl_eval / tk_eval

pop("answer=" + tcl_eval("expr {6*7}"))  # answer=42

Tool reference

cob_interp

cob_interp <file.cob> [--no-cache] [--no-gc]

Four build variants, all built from the same src/cob_interp.c:

popcorn_comp

popcorn_comp <file.strawberry> -o <output> [--no-gc] [--cc <compiler>] [--emit-c <path.c>]

Transpiles the bytecode to plain C, then spawns a real C compiler to produce a native executable. Default backend is Zig's zig cc — a Clang-based drop-in C compiler that bundles libc/CRT files for essentially every target in one install, which is what makes CobOS/CobArch cross-compiling a plain -target flag instead of needing a separately installed cross-toolchain per platform.

Compiler is resolved in this order:

CobOS=windows CobArch=amd64 popcorn_comp prog.strawberry -o prog.exe
# -> spawns: zig cc -target x86_64-windows-gnu ...

farmer

farmer harvest <package>

Fetches {registry}/api/v1/packages/<package>.json, verifies the metadata's name field matches what was requested, downloads the package zip, verifies its sha256 if one was provided, and unzips it into cob_modules/<package>/ — ready for shuck <package>.

The registry itself lives at pixel-pulse-labs/cpi, served for free via GitHub Pages — no server, just static JSON files.