programming, but make it gen z

🌳 binary tree reversal

squad TreeNode { val normie left ඞTreeNode right ඞTreeNode } slay invert_tree(root ඞTreeNode) ඞTreeNode { ready (root == nah) { damn nah } root.left, root.right = root.right, root.left invert_tree(root.left) invert_tree(root.right) damn root }

🎯 two sum (leetcode #1)

yeet "arrayz" slay two_sum(nums []normie, target normie) []normie { sus seen = new_hashmap<normie, normie>() bestie (i, num in nums) { sus complement = target - num ready (seen.has(complement)) { damn [seen.get(complement), i] } seen.set(num, i) } damn [] }

🔗 reverse linked list (leetcode #206)

squad ListNode { val normie next ඞListNode } slay reverse_list(head ඞListNode) ඞListNode { sus prev ඞListNode = nah sus current = head bestie (current != nah) { sus next = current.next current.next = prev prev = current current = next } damn prev }

🧩 longest substring (leetcode #3)

yeet "stringz" slay longest_substring(s tea) normie { sus char_map = new_hashmap<tea, normie>() sus left normie = 0 sus max_len normie = 0 bestie (right, char in s) { ready (char_map.has(char) && char_map.get(char) >= left) { left = char_map.get(char) + 1 } char_map.set(char, right) max_len = max(max_len, right - left + 1) } damn max_len }

🧠 regular expression (leetcode #10 - hard)

slay is_match(s tea, p tea) lit { sus m = s.len() sus n = p.len() sus dp = make_matrix<lit>(m+1, n+1) dp[0][0] = based bestie (i in 0..n) { ready (p[i] == '*') { dp[0][i+1] = dp[0][i-1] } } bestie (i in 0..m) { bestie (j in 0..n) { ready (p[j] == '*') { dp[i+1][j+1] = dp[i+1][j-1] ready (p[j-1] == s[i] || p[j-1] == '.') { dp[i+1][j+1] ||= dp[i][j+1] } } otherwise { ready (p[j] == s[i] || p[j] == '.') { dp[i+1][j+1] = dp[i][j] } } } } damn dp[m][n] }

💧 trapping rain water (leetcode #42 - hard)

slay trap(height []normie) normie { ready (height.len() < 3) { damn 0 } sus left = 0 sus right = height.len() - 1 sus left_max = 0 sus right_max = 0 sus water = 0 bestie (left < right) { ready (height[left] < height[right]) { ready (height[left] >= left_max) { left_max = height[left] } otherwise { water += left_max - height[left] } left++ } otherwise { ready (height[right] >= right_max) { right_max = height[right] } otherwise { water += right_max - height[right] } right-- } } damn water }

🪟 min window substring (leetcode #76 - hard)

yeet "stringz" slay min_window(s tea, t tea) tea { sus target_count = new_hashmap<tea, normie>() bestie (char in t) { target_count[char] = target_count.get(char) + 1 } sus required = target_count.size() sus formed = 0 sus window_counts = new_hashmap<tea, normie>() sus left = 0, right = 0 sus min_len = normie.max sus min_left = 0, min_right = 0 bestie (right < s.len()) { sus char = s[right] window_counts[char] = window_counts.get(char) + 1 ready (target_count.has(char) && window_counts[char] == target_count[char]) { formed++ } bestie (left <= right && formed == required) { ready (right - left + 1 < min_len) { min_len = right - left + 1 min_left = left min_right = right } sus char = s[left] window_counts[char]-- ready (target_count.has(char) && window_counts[char] < target_count[char]) { formed-- } left++ } right++ } damn min_len == normie.max ? "" : s[min_left..min_right+1] }

🚀 sliding window max (leetcode #239 - hard)

yeet "arrayz" slay max_sliding_window(nums []normie, k normie) []normie { sus result = [] sus deque = new_deque<normie>() bestie (i in 0..nums.len()) { bestie (!deque.empty() && deque.front() <= i - k) { deque.pop_front() } bestie (!deque.empty() && nums[deque.back()] <= nums[i]) { deque.pop_back() } deque.push_back(i) ready (i >= k - 1) { result.push(nums[deque.front()]) } } damn result }

Gen Z programming keywords that replace traditional language constructs:

Comments:

fr fr → line comment
no cap...on god → block comment

the following prompt was issued into a coding agent:

Hey, can you make me a programming language like Golang but all the lexical keywords are swapped so they're Gen Z slang?

and then the coding agent was left running AFK for months in a bash loop, aka Ralph Wiggum.

1/4th of a San Francisco software engineer's monthly salary

whatever Claude thought was appropriate to add

there is no roadmap. success is defined as cursed ending up in the Stack Overflow developer survey as either the "most loved" or "most hated" programming language and bootstrapping the compiler to be written in cursed itself.

fork the github repo, run claude code and do a couple more agentic loops using this prompt:

study specs/* to learn about the programming language. When authoring the cursed standard library think extra extra hard as the CURSED programming language is not in your training data set and may be invalid. Come up with a plan to implement XYZ as markdown then do it

then send in a pull-request with your most cursed code

📦 download binaries

pre-built binaries for all platforms

🚀 first program

create a file called fizzbuzz.💀

yeet "vibez"

slay main_character() {
    sus i normie = 1
    bestie i <= 100 {
        ready i % 15 == 0 {
            vibez.spill("FizzBuzz")
        } otherwise ready i % 3 == 0 {
            vibez.spill("Fizz")
        } otherwise ready i % 5 == 0 {
            vibez.spill("Buzz")
        } otherwise {
            vibez.spill(i)
        }
        i = i + 1
    }    
}

then run it with:

cursed --compile fizzbuzz.💀