An esoteric programming language that combines Go-like semantics with Gen Z slang keywords, featuring the world's first use of Among Us ඞ characters in pointer syntax.

CURSED is a statically typed programming language with a tree-walking interpreter written in Zig. It replaces traditional keywords with Gen Z slang while keeping Go-inspired semantics.

• Gen Z Slang Keywords: slay for functions, sus for variables, vibe for packages, lowkey/highkey for if/else
• Among Us Pointer Syntax: Uses ඞ (U+0D9E) for pointer operations
• Go-like Semantics: Familiar control flow, structs, interfaces, and imports
• Error Handling: yikes/fam/shook try-catch system with error propagation
• Tree-sitter Grammar: Editor syntax highlighting support
• VS Code Extension: Syntax highlighting, snippets, diagnostics, and go-to-definition

vibe main
yeet "vibez"

slay main() {
    vibez.spill("Hello, World!")
}

slay demo() {
    sus age normie = 25          // 32-bit integer
    sus name tea = "Alice"       // string
    sus is_cool lit = based      // boolean (true)
    sus height snack = 5.8       // 32-bit float

    vibez.spill("Name:", name)
}

slay calculate(x normie, y normie) normie {
    lowkey x > y {
        damn x + y
    } highkey {
        damn x - y
    }
}

slay loop_example() {
    bestie i := 0; i < 10; i++ {
        lowkey i % 2 == 0 {
            vibez.spill("Even:", i)
        }
    }
}

slay divide(a normie, b normie) normie yikes {
    lowkey b == 0 {
        yikes "Division by zero"
    }
    damn a / b
}

slay safe_division() {
    fam {
        result := divide(10, 0) shook
        vibez.spill("Result:", result)
    } sus error {
        vibez.spill("Error:", error.message())
    }
}

• Zig 0.13+
• Git

git clone https://github.com/ghuntley/cursed
cd cursed
zig build

# Run a CURSED program (interpreter)
./zig-out/bin/cursed-compiler program.💀

# Generate LLVM IR (experimental)
./zig-out/bin/cursed-compiler --emit-ir program.💀

# Debug mode with verbose output
./zig-out/bin/cursed-compiler --debug --verbose program.💀

├── src-zig/            # Zig compiler and interpreter source
├── stdlib/             # Standard library modules
├── examples/           # Example programs
├── test_suite/         # Tests including LeetCode suite
├── tools/              # VS Code extension
├── tree-sitter/        # Tree-sitter grammar
├── build/wasm/         # WASM build target
└── build.zig           # Zig build configuration

The compiler is implemented in Zig and currently operates as a tree-walking interpreter. It handles variables, functions, control flow, structs, interfaces, imports, error handling, and stdlib modules.

Working:

• Lexer and parser for the full keyword set
• Tree-walking interpreter with stdlib module imports
• Variables, arithmetic, strings, booleans, arrays
• Functions, closures, structs, interfaces, methods
• Control flow (lowkey/highkey, bestie, periodt, vibe_check)
• Error handling (fam/yikes/shook)
• later (defer) statements
• LLVM IR generation for simple programs (--emit-ir)

In progress:

• Native compilation (--compile — runtime library not yet wired up)
• Concurrency (stan/dm — parsed and partially implemented)
• Garbage collector (implemented but not yet integrated with interpreter)
• Self-hosting compiler in CURSED

Contributions welcome! See the open issues for good starting points.

1. Add tests for new features
2. Update documentation
3. Use conventional commit messages

The test_suite/leetcode_comprehensive_suite/ contains LeetCode problems across 10 categories implemented in CURSED:

• Arrays and hashing, binary search, dynamic programming
• Linked lists and trees with ඞ pointers
• String manipulation, sorting, backtracking

// LeetCode #206: Reverse Linked List with Among Us pointers
slay reverse_list(head ඞListNode) ඞListNode {
    sus prev ඞListNode = nah
    sus current ඞListNode = head

    periodt current != nah {
        sus next_temp ඞListNode = current.next
        current.next = prev
        prev = current
        current = next_temp
    }

    damn prev
}

The examples/ directory has programs covering syntax basics, error handling, HTTP servers, crypto, database integration, templates, and more.

MIT License — see LICENSE for details.

• Inspired by Go's simplicity and concurrency model
• Gen Z linguistic creativity and internet culture
• The Among Us community for the iconic ඞ character

"Stay based, avoid cringe, and always handle your yikes responsibly." 💀✨