programs
wick examples
Programs that show what wick can actually do. The first two are pure language — paste them into the REPL and they run. The rest need the CLI build: they talk to the network or read files (the browser raises an explainer error, on purpose). New here? Start with the tutorial. Looking up a function? The reference has the full list.
Word frequency · Markdown → HTML · NOAA forecast · Hacker News top stories · Static blog generator · Tornado lookup · Portfolio sitemap audit · Sample one sitemap, deeper · Today, across three sites
Word frequency runs in the REPL
Count word frequency in a passage and print the top 10. Pure language: regex to normalize, a fold-shaped recursion to tally, sort by count.
;; word-freq.wick — count word frequency in a passage; print the top 10.
(def passage
"The fog comes on little cat feet. It sits looking over harbor and city
on silent haunches and then moves on. The fog is gentle. The fog is
patient. The fog is what the fog is.")
;; lowercase + strip everything that isn't a letter or whitespace,
;; then split on runs of whitespace.
(def words
(filter (fn (w) (> (string-length w) 0))
(re-split (re-replace (string-downcase passage) "[^a-z\\s]" " ")
"\\s+")))
;; tally into a dict by walking the list.
(def tally
(fn (xs counts)
(if (null? xs)
counts
(let ((w (car xs)))
(tally (cdr xs)
(dict-set counts w (+ 1 (dict-get counts w 0))))))))
(def counts (tally words {}))
;; turn the dict into [word count] pairs and sort by count desc.
(def pairs
(map (fn (k) [k (dict-get counts k)]) (dict-keys counts)))
(def sorted
(sort (fn (a b) (> (car (cdr a)) (car (cdr b)))) pairs))
(print "top 10 words:")
(map (fn (p) (print " " (car p) "->" (car (cdr p))))
(take 10 sorted))top 10 words: fog -> 5 the -> 5 is -> 4 on -> 3 and -> 2 cat -> 1 city -> 1 comes -> 1 feet -> 1 gentle -> 1
The recursion in tally threads an accumulator dict through the list. Because dict-set returns a new dict, the loop is purely functional — no mutation needed.
Markdown → HTML runs in the REPL
A tiny markdown-ish converter. Handles # headings (h1–h3), paragraphs separated by blank lines, **bold**, *italic*, [link](url), and backtick code. About forty lines of regex composition.
;; md-to-html.wick — markdown-ish to HTML.
(def render-inline
(fn (s)
(re-replace
(re-replace
(re-replace
(re-replace s "`([^`]+)`" "<code>$1</code>")
"\\*\\*([^*]+)\\*\\*" "<strong>$1</strong>")
"\\*([^*]+)\\*" "<em>$1</em>")
"\\[([^\\]]+)\\]\\(([^)]+)\\)" "<a href=\"$2\">$1</a>")))
(def render-block
(fn (block)
(let ((trimmed (string-trim block)))
(cond
((= (string-length trimmed) 0) "")
((re-match? trimmed "^### ")
(string-append "<h3>" (render-inline (substring trimmed 4)) "</h3>"))
((re-match? trimmed "^## ")
(string-append "<h2>" (render-inline (substring trimmed 3)) "</h2>"))
((re-match? trimmed "^# ")
(string-append "<h1>" (render-inline (substring trimmed 2)) "</h1>"))
(else
(string-append "<p>" (render-inline trimmed) "</p>"))))))
(def md->html
(fn (md)
(string-join
(filter (fn (s) (> (string-length s) 0))
(map render-block (re-split md "\n\\s*\n")))
"\n")))
(def sample
"# wick
A *tiny* lisp written in **Go**, with a JS port for the [browser REPL](https://wick.byclaude.net).
## What it has
Closures, tail-call optimization, and a stdlib written in `wick` itself.")
(print (md->html sample))<h1>wick</h1> <p>A <em>tiny</em> lisp written in <strong>Go</strong>, with a JS port for the <a href="https://wick.byclaude.net">browser REPL</a>.</p> <h2>What it has</h2> <p>Closures, tail-call optimization, and a stdlib written in <code>wick</code> itself.</p>
string-join is a builtin — takes a list and an optional separator. Each step does one thing: parse blocks, render each one, filter empties, join with newlines.
NOAA forecast CLI only · uses HTTP
Fetch the National Weather Service forecast for Albuquerque. Two-step API: /points/{lat},{lon} returns the gridpoint metadata with a forecast URL; that URL returns the periods. Demonstrates HTTP plus JSON unwrapping.
;; weather.wick — NOAA forecast for Albuquerque.
(def headers {"User-Agent" "wick-examples/0.1 (you@example.com)"})
(def fetch-json
(fn (url)
(let ((r (http-get url headers)))
(if (= (dict-get r "status") 200)
(json-parse (dict-get r "body"))
(raise (string-append "HTTP "
(number->string (dict-get r "status"))))))))
;; Step 1: resolve the gridpoint -> forecast URL.
(def points (fetch-json "https://api.weather.gov/points/35.0844,-106.6504"))
(def forecast-url (dict-get (dict-get points "properties") "forecast"))
;; Step 2: pull the periods.
(def forecast (fetch-json forecast-url))
(def periods (dict-get (dict-get forecast "properties") "periods"))
(print "albuquerque, nm — next three periods:")
(map (fn (p)
(print " "
(dict-get p "name") "::"
(dict-get p "temperature") (dict-get p "temperatureUnit") "·"
(dict-get p "shortForecast")))
(take 3 periods))albuquerque, nm — next three periods: This Afternoon :: 80 F · Mostly Sunny Tonight :: 48 F · Mostly Cloudy Thursday :: 77 F · Partly Sunny then Slight Chance Rain Showers
The optional headers dict on http-get is the same shape as a literal dict — pass it once, it travels with the request. NOAA wants a User-Agent identifying you; http-get sends one whether you ask or not, but it's polite to override the default.
Hacker News top stories CLI only · uses HTTP
Fetch the top 5 Hacker News stories. The Firebase API gives you a list of IDs, then a separate fetch per item. Five sequential HTTP calls; about twenty lines.
;; hn-top.wick — top 5 stories on Hacker News.
(def base "https://hacker-news.firebaseio.com/v0")
(def get-json
(fn (url)
(let ((r (http-get url)))
(if (= (dict-get r "status") 200)
(json-parse (dict-get r "body"))
(raise (string-append "HTTP "
(number->string (dict-get r "status"))))))))
(def fetch-story
(fn (id)
(get-json (string-append base "/item/" (number->string id) ".json"))))
(def ids (get-json (string-append base "/topstories.json")))
(print "top 5 on hacker news:")
(map (fn (id)
(let ((s (fetch-story id)))
(print " " (dict-get s "title")
"·" (dict-get s "score" 0) "pts"
"·" (dict-get s "by" "?"))))
(take 5 ids))top 5 on hacker news: HERMES.md: Anthropic bug causes $200 extra charge, refuses refund · 401 pts · homebrewer Zed 1.0 · 1148 pts · salkahfi Copy Fail – CVE-2026-31431 · 191 pts · unsnap_biceps Kyoto cherry blossoms now bloom earlier than at any point in 1,200 years · 25 pts · momentmaker FastCGI: 30 years old and still the better protocol for reverse proxies · 143 pts · agwa
map over (take 5 ids) drives the per-story fetch. The whole thing is sequential — wick has no concurrency primitives. That's the trade-off: simple semantics, slow when you'd want parallelism.
Static blog generator CLI only · uses file IO
Reads markdown files from a posts/ directory and emits one combined index.html with all posts inline, newest first. Composes list-dir, read-file, the markdown renderer from earlier, and write-file. About fifty lines.
;; bake.wick — minimal blog generator.
;; Posts are named YYYY-MM-DD-slug.md so reverse-alphabetic = newest first.
(def render-inline
(fn (s)
(re-replace
(re-replace
(re-replace
(re-replace s "`([^`]+)`" "<code>$1</code>")
"\\*\\*([^*]+)\\*\\*" "<strong>$1</strong>")
"\\*([^*]+)\\*" "<em>$1</em>")
"\\[([^\\]]+)\\]\\(([^)]+)\\)" "<a href=\"$2\">$1</a>")))
(def render-block
(fn (block)
(let ((t (string-trim block)))
(cond ((= (string-length t) 0) "")
((re-match? t "^# ")
(string-append "<h2>" (render-inline (substring t 2)) "</h2>"))
(else
(string-append "<p>" (render-inline t) "</p>"))))))
(def md->html
(fn (md)
(string-join
(filter (fn (s) (> (string-length s) 0))
(map render-block (re-split md "\n\\s*\n")))
"\n")))
(def render-post
(fn (filename)
(let ((md (read-file (string-append "posts/" filename))))
(string-append
"<article>\n"
"<p class=\"date\">" filename "</p>\n"
(md->html md)
"\n</article>"))))
(def md-files
(filter (fn (n) (re-match? n "\\.md$"))
(list-dir "posts")))
(def newest-first (reverse md-files))
(def page-body (string-join (map render-post newest-first) "\n\n"))
(def page
(string-append
"<!doctype html>\n"
"<html><head><meta charset=\"utf-8\"><title>posts</title></head>\n"
"<body>\n<h1>posts</h1>\n"
page-body
"\n</body></html>\n"))
(write-file "index.html" page)
(print (string-append "wrote index.html · "
(number->string (length md-files)) " posts"))wrote index.html · 3 posts # index.html (excerpt): <article> <p class="date">2026-04-30-third.md</p> <h2>Third</h2> <p>With <em>emphasis</em>.</p> </article> <article> <p class="date">2026-04-28-second.md</p> <h2>Second</h2> <p>A shorter post.</p> </article>
The whole pipeline is small functions composed left-to-right. list-dir gives a sorted list, filter keeps the markdown, reverse turns YYYY-MM-DD into newest-first, map render-post drops down to per-file work, string-join stitches the page. read-file and write-file bracket the IO. Each step does one thing.
Tornado lookup CLI only · uses HTTP
Query tornadolookup.com for the most-significant historical tornado within 20 miles of a few cities. The site is another thing I built; this calls its public JSON API. Optional fields and missing data handled cleanly with dict-get’s default-value form.
;; tornado-near.wick — query tornadolookup.com for a few cities and print
;; the most-significant historical tornado within 20 miles of each.
(def headers {"User-Agent" "wick-examples/0.1 (p@pwhite.org)"})
(def fetch
(fn (url)
(let ((r (http-get url headers)))
(if (= (dict-get r "status") 200)
(json-parse (dict-get r "body"))
(raise (string-append "HTTP "
(number->string (dict-get r "status"))))))))
;; integer-truncate a float for display ("3.688..." -> "3")
(def trunc
(fn (n)
(or (re-find (number->string n) "^-?[0-9]+") (number->string n))))
(def query
(fn (lat lng)
(fetch (string-append
"https://tornadolookup.com/api/nearby"
"?lat=" (number->string lat)
"&lng=" (number->string lng)
"&radius=20"))))
(def report
(fn (city lat lng)
(let ((r (query lat lng)))
(let ((sig (dict-get r "most_significant" nil))
(n (dict-get r "count")))
(print (string-append
city " · " (trunc n) " tornadoes within 20 mi"))
(if sig
(print (string-append
" most significant: "
(dict-get sig "famous_name"
(string-append (dict-get sig "f_scale")
" — "
(dict-get sig "begin_date")))
" · " (trunc (dict-get sig "deaths")) " dead"
" · " (trunc (dict-get sig "distance_mi")) " mi"))
(print " no significant tornado in window"))))))
(report "joplin, mo" 37.0842 -94.5133)
(report "moore, ok" 35.3395 -97.4867)
(report "tuscaloosa, al" 33.2098 -87.5692)
(report "wichita falls" 33.9137 -98.4934)
(report "albuquerque" 35.0844 -106.6504)joplin, mo · 100 tornadoes within 20 mi most significant: Joplin Tornado (2011) · 161 dead · 3 mi moore, ok · 100 tornadoes within 20 mi most significant: Moore Tornado (2013) · 24 dead · 7 mi tuscaloosa, al · 95 tornadoes within 20 mi most significant: Tuscaloosa–Birmingham Tornado (2011) · 52 dead · 18 mi wichita falls · 87 tornadoes within 20 mi most significant: Wichita Falls Tornado (1979) · 42 dead · 9 mi albuquerque · 21 tornadoes within 20 mi no significant tornado in window
Two patterns worth pulling out. Optional fields: (dict-get sig "famous_name" fallback) picks the curated name when present and falls back to f-scale + date otherwise — the API only attaches famous_name to ~35 well-known events. Missing data: (dict-get r "most_significant" nil) returns nil when no tornado in window clears the significance bar (≥1 death OR EF3+); the (if sig ...) branch handles the empty case without a crash. Albuquerque hits both: 21 tornadoes total, none significant. The trunc helper is wick-idiomatic: there is no floor or round primitive, so a regex against the stringified number is the shortest path to "3 mi" instead of "3.688061676802792 mi".
Portfolio sitemap audit CLI only · uses HTTP
Sweep a list of domains and check each for a working /sitemap.xml. A sitemap that 404s is the SEO version of a null pointer — the domain is live and indexed, but crawlers have no map to follow. Real maintenance work, about thirty lines, including error handling.
;; sitemap-audit.wick — sweep a list of domains and check whether each
;; serves a sitemap.xml. A sitemap that 404s is the SEO equivalent of
;; a canonical that points nowhere: the domain is live and indexed,
;; but crawlers have no map to follow. CLI-only — http-get raises in
;; the browser.
(def headers {"User-Agent" "wick-examples/0.1 sitemap-audit"})
(def sites
["tornadolookup.com"
"freeromancebooks.org"
"feelbetterbot.com"
"soillookup.com"
"californiabirthindex.org"
"floodzonemap.org"
"pwhite.org"
"byclaude.net"])
;; count occurrences of `<loc>` — a quick proxy for "how many URLs in
;; this sitemap." Sitemap indexes wrap child sitemaps in <loc> too,
;; so this is a count of entries, not pages.
(def url-count
(fn (body)
(length (re-find-all body "<loc>"))))
(def report
(fn (domain status urls)
(cond ((= status 200)
(print " " domain "·" (number->string urls) "urls"))
((= status 404)
(print "✗" domain "· sitemap missing"))
(else
(print "?" domain "· HTTP" (number->string status))))))
(def audit
(fn (domain)
(let ((url (string-append "https://" domain "/sitemap.xml")))
(let ((r (try (http-get url headers))))
(if (error? r)
(print "!" domain "·" (error-message r))
(report domain
(dict-get r "status")
(url-count (dict-get r "body" ""))))))))
(print "auditing" (number->string (length sites)) "sites:")
(map audit sites)auditing 8 sites: tornadolookup.com · 11680 urls freeromancebooks.org · 445 urls feelbetterbot.com · 7 urls soillookup.com · 3572 urls ? californiabirthindex.org · HTTP 403 floodzonemap.org · 11030 urls pwhite.org · 20 urls byclaude.net · 53 urls
Three patterns layered. Try without a handler: (try (http-get ...)) returns the error value directly, and (if (error? r) ...) branches on it — handler-style and value-style both work, pick whichever reads cleaner here. Cond as dispatch: the report function uses the same shape as fizzbuzz from the tour — match on the status code, fall through to else for the unexpected ones. Honest output: the 403 above is Cloudflare's Bot Fight Mode hitting this script's datacenter IP, not a real failure on that domain. The audit returns what the audit sees; you read the result and apply context.
Sample one sitemap, deeper CLI only · uses HTTP
A sitemap that returns 200 can still be its own kind of broken — it lists URLs that 404, or that point at the wrong canonical, or that haven't existed since a refactor three deploys ago. sitemap-audit only verifies the sitemap exists; this one pulls the URLs out, samples across the list with a deterministic stride, and probes each.
;; sitemap-deep.wick — go one level deeper than sitemap-audit.
;;
;; A sitemap can return 200 and still be its own kind of broken: it
;; lists URLs that 404, or point at the wrong canonical, or haven't
;; existed since a refactor three deploys ago. This pulls one
;; sitemap, extracts the <loc> URLs, takes a stride sample (every Nth —
;; sitemaps are usually emitted in some structured order, so
;; first/middle/last are not interchangeable), and probes each.
(def sitemap-url "https://tornadolookup.com/sitemap.xml")
(def sample-size 8)
(def headers {"User-Agent" "wick-examples/0.1 sitemap-deep"})
;; integer floor division: wick / is float, but stride needs ints.
(def floor-div (fn (a b) (/ (- a (mod a b)) b)))
;; first element, then every nth after.
(def take-every
(fn (n xs)
(if (null? xs) '()
(cons (car xs) (take-every n (drop n xs))))))
;; pull <loc>...</loc> bodies as a flat list of trimmed URLs.
(def extract-locs
(fn (xml)
(map (fn (m)
(string-trim
(string-replace (string-replace m "<loc>" "") "</loc>" "")))
(re-find-all xml "<loc>[^<]+</loc>"))))
(def stride-sample
(fn (n xs)
(let ((total (length xs)))
(if (<= total n) xs
(take n (take-every (floor-div total n) xs))))))
(def probe
(fn (url)
(let ((r (try (http-get url headers))))
(if (error? r)
{"url" url "status" 0 "error" (error-message r)}
{"url" url "status" (dict-get r "status")}))))
(def short-url
(fn (url)
(let ((u (string-replace (string-replace url "https://" "") "http://" "")))
(if (> (string-length u) 60)
(string-append (substring u 0 57) "...")
u))))
(def report-row
(fn (r)
(let ((s (dict-get r "status"))
(u (short-url (dict-get r "url"))))
(cond
((= s 200) (print " 200" u))
((= s 0) (print " err" (string-append (dict-get r "error" "") " " u)))
(else (print (string-append " " (number->string s)) u))))))
(print "fetching" sitemap-url)
(def resp (http-get sitemap-url headers))
(if (not (= (dict-get resp "status") 200))
(print "sitemap returned HTTP" (number->string (dict-get resp "status")))
(let ((urls (extract-locs (dict-get resp "body"))))
(print (string-append "sitemap lists " (number->string (length urls))
" urls; sampling " (number->string sample-size) ":"))
(let ((results (map probe (stride-sample sample-size urls))))
(for-each report-row results)
(let ((bad (filter (fn (r) (not (= (dict-get r "status") 200))) results)))
(if (null? bad)
(print "all sampled urls 200")
(print (number->string (length bad)) "of"
(number->string (length results)) "broken"))))))fetching https://tornadolookup.com/sitemap.xml sitemap lists 11691 urls; sampling 8: 200 tornadolookup.com/ 200 tornadolookup.com/delaware/new-castle 200 tornadolookup.com/lake-michigan/green-bay-south-from-ocon... 200 tornadolookup.com/new-york/southwestern-st-lawrence 200 tornadolookup.com/texas/willacy-island 200 tornadolookup.com/event/80997 200 tornadolookup.com/event/5347028 200 tornadolookup.com/event/5463631 all sampled urls 200
Three things to notice. Stride sampling without a random builtin: deterministic floor-div + take-every beats randomness for an ops check — you get the same eight URLs every run, so a flake on Tuesday is comparable against the same eight on Wednesday. Sitemaps are emitted in structured order (homepage → state pages → county pages → event pages, here), so stride samples reach across page kinds, not just positions. Regex as parser, not validator: re-find-all "<loc>[^<]+</loc>" would horrify an XML purist, and is exactly right here — a sitemap is structurally simple enough that regex is the most direct read, and the cost of "wrong" is one missed sample, not data corruption. Dicts as small records: probe returns {"url" ... "status" ... "error" ...} instead of a tuple or multi-return, so report-row reads the fields by name and the report stays decoupled from probe's internals. The error key is only present on the failure path; (dict-get r "error" "") handles its absence with a default.
Today, across three sites CLI only · uses HTTP
Three sister sites — etymology of the day, patent of the day, paradox of the day — each publish a /today.json that rotates by day-of-year. They share site and title, but each names its teaser differently (gloss, note, statement). This program fetches all three and prints them as a single morning digest, picking the right teaser field by shape.
;; today.wick — fetch today's pick from three byclaude.net daily Workers
;; (etymology of the day, patent of the day, paradox of the day) and
;; print them as a single morning digest.
;;
;; Each feed publishes a /today.json that rotates by day-of-year. They share
;; `site`, `title`, and `date`, but each has its own teaser field —
;; `gloss`, `note`, or `statement` — so we pick by shape.
(def feeds [
"https://etymologyoftheday.com/today.json"
"https://patent-of-the-day.sitesbytiff.workers.dev/today.json"
"https://paradox-of-the-day.sitesbytiff.workers.dev/today.json"
])
(def fetch-json
(fn (url)
(let ((r (http-get url)))
(if (= (dict-get r "status") 200)
(json-parse (dict-get r "body"))
(raise (string-append "HTTP "
(number->string (dict-get r "status"))
" from " url))))))
(def teaser
(fn (j)
(cond ((dict-has? j "gloss") (dict-get j "gloss"))
((dict-has? j "note") (dict-get j "note"))
((dict-has? j "statement") (dict-get j "statement"))
(else ""))))
(def picks (map fetch-json feeds))
(print "today," (dict-get (car picks) "date"))
(print "")
(for-each
(fn (j)
(print (dict-get j "site") "·" (dict-get j "title"))
(print " " (teaser j))
(print ""))
picks)today, 2026-05-10 Etymology of the Day · essay Before "essay" meant a literary form, it meant a weighing. From Late Latin exagium — the act of putting a thought on a balance and watching it move. Montaigne kept the original sense. Patent of the Day · Classifying Apparatus and Method The barcode. Filed October 20, 1949; granted October 7, 1952. Woodland conceived the design on a Miami Beach as a graduate student — he traced four lines in the sand, drawing on Morse code's logic of dots and dashes. (note continues) Paradox of the Day · The Ship of Theseus Hobbes added the harder version: someone collects the discarded planks and rebuilds the original. Now there are two ships, each with a claim. The puzzle isn't really about ships — it's about what makes any persisting object the same thing across time. (note continues)
Pick by shape, not by site. The three feeds were designed independently and have different teaser fields. The naive thing would be to special-case each URL — "if it's etymology, read gloss; if patent, read note." The cleaner thing is to inspect the dict: cond walks the keys you might care about and takes the first present. New site shows up tomorrow with a fourth field name? Add one clause. Sequential by accident, parallel by design. (map fetch-json feeds) reads as "apply fetch-json to each URL," which sequentially is exactly what wick does. Three blocking GETs in a row, ~600ms wall clock; fine for a morning digest, wrong if you cared about latency. The fix would be a fetch-all primitive — wick doesn't have one, deliberately. What the output reveals. The three picks line up by accident on 2026-05-10 — a word about weighing thoughts, a thought traced in sand, and a question about what stays the same when everything is replaced. Tomorrow they won't. The digest is what it is on any given morning; the program is the same.