engineering/lumbda
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rename: uncommonlisp -> lumbda throughout the repo

Browse source 
Historical internal name "uncommonlisp" retired in favor of the
public name "lumbda" ahead of lumbda.com going live. Scope of
this commit:

Source files renamed:
  uncommonlisp.py                     -> lumbda.py
  asm/uncommonlisp.s                  -> asm/lumbda.s
  c/uncommonlisp.h                    -> c/lumbda.h
  whitepaper/uncommonlisp-whitepaper  -> whitepaper/lumbda-whitepaper (.rst + .pdf)

Binaries renamed (tracked ones; c/ was always gitignored):
  asm/uncommonlisp, asm/uncommonlisp-gc, asm/uncommonlisp.o,
  asm/uncommonlisp-gc.o                -> asm/lumbda(-gc)(.o)
  c/.gitignore                          -> ignores lumbda

Internal string updates (sed pass ordered longest-first):
  asm/uncommonlisp -> asm/lumbda
  c/uncommonlisp   -> c/lumbda
  uncommonlisp.py  -> lumbda.py
  UNCOMMONLISP_BIN -> LUMBDA_BIN (asm/test.sh env var)
  "uncommonlisp> " -> "lumbda> " (asm REPL prompt baked into binary)
  UNCOMMONLISP     -> LUMBDA (macros, comments)
  uncommonlisp     -> lumbda (prose)

Binary portal magic updated:
  "ULPORTAL" -> "LUMBDAB1"   # "Lumbda Binary v1"
Old portal files are not backward-compatible — this is a deliberate
break since it's the rename moment. S-expression portals already
carry their own ";; lumbda-portal v1" header and remain cleanly
versioned.

WHITEPAPER.pdf / WHITEPAPER.rst symlinks repointed to the renamed
files. Makefile's whitepaper target targets lumbda-whitepaper.pdf.

Not changed (intentional, separate phases):
  - Filesystem directory /home/fox/git/uncommonlisp itself
    (fox renames locally and the gitlab repo URL in a follow-up)
  - tests.py hardcoded cwd=/home/fox/git/uncommonlisp
    (matches the current on-disk location; will flip when the
    directory rename ships)
  - Git history (immutable; old commits still say uncommonlisp,
    which is correct — that's what they were)

Verified:
  137 asm no-GC + 137 asm GC + 571 Python + 83 C + 189 shared
  functional tests all pass under the new names.
  bench-gc-http (2000 req): all 4 cells behave as expected
  (cells 1/2 flat, 3 leaks, 4 bounded at 1 chunk).
  Python REPL, C REPL, asm REPL all start cleanly.
This commit is contained in:
russell@unturf.com 2026-04-19 10:20:11 -04:00
parent 9e54c7aaf1
commit f7352b51b0
77 changed files with 383 additions and 383 deletions
Download patch file Download diff file Expand all files Collapse all files

6
tests/bench-3way.sh
View file

@ -60,15 +60,15 @@ best_of_two() {
}
echo "── Python (--fast) ──"
best_of_two "python3 uncommonlisp.py --fast /tmp/bench-3way.lsp"
best_of_two "python3 lumbda.py --fast /tmp/bench-3way.lsp"
echo
echo "── C (--fast) ──"
best_of_two "c/uncommonlisp --fast /tmp/bench-3way.lsp"
best_of_two "c/lumbda --fast /tmp/bench-3way.lsp"
echo
echo "── asm ──"
best_of_two "asm/uncommonlisp < /tmp/bench-3way.lsp"
best_of_two "asm/lumbda < /tmp/bench-3way.lsp"
echo
rm -f /tmp/bench-3way.lsp

6
tests/bench-gc-adaptive.sh
View file

@ -6,7 +6,7 @@ set -e
cd "$(dirname "$0")/.."
ulimit -v 524288
trap 'pkill -9 -u "$USER" -f "asm/uncommonlisp" 2>/dev/null || true' EXIT
trap 'pkill -9 -u "$USER" -f "asm/lumbda" 2>/dev/null || true' EXIT
make -s -C asm all
@ -20,7 +20,7 @@ run_phase() {
echo "(define *workload* $workload)"
echo "(define *mode* $mode)"
cat examples/bench-gc-adaptive.lsp
} | timeout 60 ./asm/uncommonlisp-gc
} | timeout 60 ./asm/lumbda-gc
echo ""
}
@ -31,7 +31,7 @@ run_phase "hostile" 1 1 "adaptive"
run_phase "mixed" 2 0 "greedy"
run_phase "mixed" 2 1 "adaptive"
if pgrep -u "$USER" -f 'asm/uncommonlisp' > /dev/null; then
if pgrep -u "$USER" -f 'asm/lumbda' > /dev/null; then
echo "STRAGGLER" >&2
exit 1
fi

6
tests/bench-gc-arena.sh
View file

@ -7,12 +7,12 @@ set -e
cd "$(dirname "$0")/.."
ulimit -v 524288
trap 'pkill -9 -u "$USER" -f "asm/uncommonlisp" 2>/dev/null || true' EXIT
trap 'pkill -9 -u "$USER" -f "asm/lumbda" 2>/dev/null || true' EXIT
make -s -C asm all
echo "== asm (naive GC, with arena as meta fast path) =="
./asm/uncommonlisp-gc < examples/bench-gc-arena.lsp &
./asm/lumbda-gc < examples/bench-gc-arena.lsp &
pid=$!
peak=0
while kill -0 "$pid" 2>/dev/null; do
@ -24,7 +24,7 @@ wait "$pid" || true
echo ""
echo "peak_rss_kb=$peak"
if pgrep -u "$USER" -f 'asm/uncommonlisp' > /dev/null; then
if pgrep -u "$USER" -f 'asm/lumbda' > /dev/null; then
echo "STRAGGLER" >&2
exit 1
fi

8
tests/bench-gc-http.sh
View file

@ -96,9 +96,9 @@ run_case() {
# to completion rather than OOM'd.
VCAP=${VCAP:-524288}
run_case "asm no-GC + snapshot loop" "./asm/uncommonlisp" "examples/http-server.lsp" "$VCAP" || true
run_case "asm GC + snapshot loop" "./asm/uncommonlisp-gc" "examples/http-server.lsp" "$VCAP" || true
run_case "asm no-GC + no snapshot" "./asm/uncommonlisp" "examples/http-server-noarena.lsp" "$VCAP" || true
run_case "asm GC + no snapshot" "./asm/uncommonlisp-gc" "examples/http-server-noarena.lsp" "$VCAP" || true
run_case "asm no-GC + snapshot loop" "./asm/lumbda" "examples/http-server.lsp" "$VCAP" || true
run_case "asm GC + snapshot loop" "./asm/lumbda-gc" "examples/http-server.lsp" "$VCAP" || true
run_case "asm no-GC + no snapshot" "./asm/lumbda" "examples/http-server-noarena.lsp" "$VCAP" || true
run_case "asm GC + no snapshot" "./asm/lumbda-gc" "examples/http-server-noarena.lsp" "$VCAP" || true
printf "\n"

8
tests/bench-gc-memory.sh
View file

@ -7,7 +7,7 @@ set -e
cd "$(dirname "$0")/.."
ulimit -v 524288
trap 'pkill -9 -u "$USER" -f "asm/uncommonlisp" 2>/dev/null || true' EXIT
trap 'pkill -9 -u "$USER" -f "asm/lumbda" 2>/dev/null || true' EXIT
make -s -C asm all
@ -35,12 +35,12 @@ run_with_sampling() {
echo ""
}
run_with_sampling ./asm/uncommonlisp "asm (no GC, 64 MB chunks)"
run_with_sampling ./asm/uncommonlisp-gc "asm (naive GC, 1 MB chunks)"
run_with_sampling ./asm/lumbda "asm (no GC, 64 MB chunks)"
run_with_sampling ./asm/lumbda-gc "asm (naive GC, 1 MB chunks)"
rm -f /tmp/gc-bench.out
if pgrep -u "$USER" -f 'asm/uncommonlisp' > /dev/null; then
if pgrep -u "$USER" -f 'asm/lumbda' > /dev/null; then
echo "STRAGGLER detected" >&2
exit 1
fi

12
tests/bench-hashset.sh
View file

@ -5,26 +5,26 @@ set +e
cd "$(dirname "$0")/.."
ulimit -v 524288
trap 'pkill -9 -u "$USER" -f "asm/uncommonlisp" 2>/dev/null || true' EXIT
trap 'pkill -9 -u "$USER" -f "asm/lumbda" 2>/dev/null || true' EXIT
# Build if needed
if [ ! -x asm/uncommonlisp ] || [ asm/uncommonlisp.s -nt asm/uncommonlisp ]; then
if [ ! -x asm/lumbda ] || [ asm/lumbda.s -nt asm/lumbda ]; then
make -s asm-build
fi
echo "── asm no-GC ──"
timeout 60 ./asm/uncommonlisp < examples/bench-hashset.lsp
timeout 60 ./asm/lumbda < examples/bench-hashset.lsp
echo ""
echo "── asm GC (GC_NAIVE build) ──"
# Under GC_NAIVE the heap is 1 MB per chunk; build-list(K=500) runs
# into the bump threshold and triggers implicit GC. That's the
# intended comparison — same primitives, different allocator.
timeout 60 ./asm/uncommonlisp-gc < examples/bench-hashset.lsp
timeout 60 ./asm/lumbda-gc < examples/bench-hashset.lsp
# Verify cleanup. pgrep with -x matches the exact command basename
# so it doesn't false-positive on the parent shell.
if pgrep -u "$USER" -x uncommonlisp > /dev/null || \
pgrep -u "$USER" -x uncommonlisp-gc > /dev/null; then
if pgrep -u "$USER" -x lumbda > /dev/null || \
pgrep -u "$USER" -x lumbda-gc > /dev/null; then
echo "STRAGGLER asm binary detected" >&2
exit 1
fi

16
tests/bench-proof.sh
View file

@ -52,17 +52,17 @@ echo "════════════════════════
printf " %-38s %s\n" "Lumbda tier" "cold cached"
printf " %-38s %s\n" "─────────────────────────────────────" "───────────────"
printf " %-38s %4s ms %4s ms\n" "Python --fast" \
"$(bestof_cold 'python3 uncommonlisp.py --fast proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'python3 uncommonlisp.py --fast proof/eml_proof_in_lumbda.lsp')"
"$(bestof_cold 'python3 lumbda.py --fast proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'python3 lumbda.py --fast proof/eml_proof_in_lumbda.lsp')"
printf " %-38s %4s ms %4s ms\n" "C (tree-walker)" \
"$(bestof_cold 'c/uncommonlisp proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'c/uncommonlisp proof/eml_proof_in_lumbda.lsp')"
"$(bestof_cold 'c/lumbda proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'c/lumbda proof/eml_proof_in_lumbda.lsp')"
printf " %-38s %4s ms %4s ms\n" "C --fast (bytecode VM)" \
"$(bestof_cold 'timeout 15 c/uncommonlisp --fast proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'timeout 15 c/uncommonlisp --fast proof/eml_proof_in_lumbda.lsp')"
"$(bestof_cold 'timeout 15 c/lumbda --fast proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'timeout 15 c/lumbda --fast proof/eml_proof_in_lumbda.lsp')"
printf " %-38s %4s ms %4s ms\n" "asm" \
"$(bestof_cold 'asm/uncommonlisp < proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'asm/uncommonlisp < proof/eml_proof_in_lumbda.lsp')"
"$(bestof_cold 'asm/lumbda < proof/eml_proof_in_lumbda.lsp')" \
"$(bestof_cached 'asm/lumbda < proof/eml_proof_in_lumbda.lsp')"
echo ""
echo " Lean 4 comparison:"

10
tests/functional.lsp
View file

@ -1,8 +1,8 @@
;;; functional.lsp — Shared functional test suite
;;; Runs identically in both Python and C implementations.
;;;
;;; Python: python3 uncommonlisp.py --fast tests/functional.lsp
;;; C: ./c/uncommonlisp tests/functional.lsp
;;; Python: python3 lumbda.py --fast tests/functional.lsp
;;; C: ./c/lumbda tests/functional.lsp
;;;
;;; Output: lines of "PASS: name" or "FAIL: name got=X expected=Y"
;;; Exit: displays summary at end
@ -595,11 +595,11 @@
;;; File I/O: write-file / file->string round-trip
;;; ═══════════════════════════════════════════════════════════════
(define *tmp-path* "/tmp/uncommonlisp-functional-fio.txt")
(define *tmp-path* "/tmp/lumbda-functional-fio.txt")
(assert-true "write-file basic" (write-file *tmp-path* "hello\n"))
(assert-equal "file->string round-trip" (file->string *tmp-path*) "hello\n")
(assert-false "file->string missing" (file->string "/tmp/__nope_uncommonlisp_fio__"))
(assert-false "file->string missing" (file->string "/tmp/__nope_lumbda_fio__"))
(assert-true "write-file overwrite"
(begin (write-file *tmp-path* "second") (string=? (file->string *tmp-path*) "second")))
@ -608,7 +608,7 @@
;;; Cross-impl state exchange using only string primitives
;;; ═══════════════════════════════════════════════════════════════
(define *portal-path* "/tmp/uncommonlisp-functional-portal.sexp")
(define *portal-path* "/tmp/lumbda-functional-portal.sexp")
(write-file *portal-path*
"(define portal-x 111)\n(define portal-y 222)\n(define portal-z 333)\n")

6
tests/portal-benchmark.sh
View file

@ -11,9 +11,9 @@
set -u
cd "$(dirname "$0")/.."
PY="python3 uncommonlisp.py --fast"
C="./c/uncommonlisp"
ASM="./asm/uncommonlisp"
PY="python3 lumbda.py --fast"
C="./c/lumbda"
ASM="./asm/lumbda"
N=50
pad() { printf " %-42s " "$1"; }

6
tests/portal-cross-test.sh
View file

@ -13,9 +13,9 @@
set -e
cd "$(dirname "$0")/.."
PY="python3 uncommonlisp.py --fast"
C="./c/uncommonlisp"
ASM="./asm/uncommonlisp"
PY="python3 lumbda.py --fast"
C="./c/lumbda"
ASM="./asm/lumbda"
SEXP=/tmp/portal-xtest.sexp
PASS=0

2
tests/portal-exchange.lsp
View file

@ -16,7 +16,7 @@
;; Write all user-defined bindings as (define name value) forms
;; that any Scheme can evaluate to restore state
(let ((port (open-output-file filename)))
(display ";; uncommonlisp portable state" port)
(display ";; lumbda portable state" port)
(newline port)
(display ";; generated by portal-save-sexp" port)
(newline port)

8
tests/portal-formats.lsp
View file

@ -4,9 +4,9 @@
;;; 2. JSON (Python + C)
;;; 3. Binary heap dump (assembly only, fastest)
;;;
;;; Run in Python: python3 uncommonlisp.py --fast tests/portal-formats.lsp
;;; Run in C: ./c/uncommonlisp tests/portal-formats.lsp
;;; Asm: asm/uncommonlisp < tests/portal-cross-load.lsp (no `load` builtin)
;;; Run in Python: python3 lumbda.py --fast tests/portal-formats.lsp
;;; Run in C: ./c/lumbda tests/portal-formats.lsp
;;; Asm: asm/lumbda < tests/portal-cross-load.lsp (no `load` builtin)
;;;
;;; ── Observed results (2026-04-16, same laptop) ─────────────────
;;;
@ -47,7 +47,7 @@
(define (write-sexp-portal filename)
(let ((port (open-output-file filename)))
;; Header
(display ";; uncommonlisp portable state (S-expression format)" port)
(display ";; lumbda portable state (S-expression format)" port)
(newline port)
(display ";; resume: (load \"" port)
(display filename port)

12
tests/rpc-chain-bench.sh
View file

@ -24,7 +24,7 @@ SPAWNED=()
cleanup() {
for pid in "${SPAWNED[@]}"; do kill -9 "$pid" 2>/dev/null; done
sleep 0.2
pkill -9 -u "$USER" -f 'uncommonlisp.*(rpc|repl)-(server|relay|chain-bench)\.lsp' 2>/dev/null || true
pkill -9 -u "$USER" -f 'lumbda.*(rpc|repl)-(server|relay|chain-bench)\.lsp' 2>/dev/null || true
}
trap cleanup EXIT INT TERM
@ -61,17 +61,17 @@ stop_bg() {
verify_clean() {
local strays
strays=$(pgrep -u "$USER" -f 'uncommonlisp.*(rpc|repl)-(server|relay|chain-bench)\.lsp' 2>/dev/null || true)
strays=$(pgrep -u "$USER" -f 'lumbda.*(rpc|repl)-(server|relay|chain-bench)\.lsp' 2>/dev/null || true)
if [ -n "$strays" ]; then
echo "!! STRAYS: $strays" >&2
pkill -9 -u "$USER" -f 'uncommonlisp.*(rpc|repl)-(server|relay|chain-bench)\.lsp' 2>/dev/null || true
pkill -9 -u "$USER" -f 'lumbda.*(rpc|repl)-(server|relay|chain-bench)\.lsp' 2>/dev/null || true
return 1
fi
}
PY="python3 uncommonlisp.py --fast"
C="./c/uncommonlisp"
ASM="./asm/uncommonlisp"
PY="python3 lumbda.py --fast"
C="./c/lumbda"
ASM="./asm/lumbda"
# Always use Python client to drive (identical across benches).
# We sed the hardcoded port in-place because asm's top-level

36
tests/web-benchmark.sh
View file

@ -1,5 +1,5 @@
#!/bin/bash
# web-benchmark.sh — race the three uncommonlisp HTTP servers
# web-benchmark.sh — race the three lumbda HTTP servers
# against Python http.server and busybox httpd.
#
# No wrk/ab/nginx dependency — we use xargs+curl for concurrency.
@ -12,10 +12,10 @@ cd "$(dirname "$0")/.."
REQUESTS=${REQUESTS:-500}
CONCURRENCY=${CONCURRENCY:-10}
PY="python3 uncommonlisp.py --fast"
C="./c/uncommonlisp"
ASM="./asm/uncommonlisp"
ASM_GC="./asm/uncommonlisp-gc"
PY="python3 lumbda.py --fast"
C="./c/lumbda"
ASM="./asm/lumbda"
ASM_GC="./asm/lumbda-gc"
# Track every server PID we spawn; the EXIT trap kills them all.
# Asm has no GC — a leaked server leaks 64 MB per heap growth
@ -34,7 +34,7 @@ cleanup() {
rm -rf "${STATIC_DIR:-/nonexistent/xyz}"
# Final sanity: any stray servers from examples/http-server?
# Narrow to processes actually serving the HTTP example, not the
# shell running this script or tmux sessions with "uncommonlisp"
# shell running this script or tmux sessions with "lumbda"
# in their name.
local strays
strays=$(pgrep -u "$USER" -f 'examples/http-server\.lsp|http\.server 8080' | wc -l)
@ -106,25 +106,25 @@ stop_server() {
sleep 0.2
}
# ── uncommonlisp Python ──
# ── lumbda Python ──
PID=$(start_server "$PY examples/http-server.lsp" 8080)
bench_one "uncommonlisp Python (/bench, 1 KB)" 8080 /bench
bench_one "lumbda Python (/bench, 1 KB)" 8080 /bench
stop_server "$PID"
# ── uncommonlisp C ──
# ── lumbda C ──
PID=$(start_server "$C examples/http-server.lsp" 8080)
bench_one "uncommonlisp C (/bench, 1 KB)" 8080 /bench
bench_one "lumbda C (/bench, 1 KB)" 8080 /bench
stop_server "$PID"
# ── uncommonlisp asm (bump-only) ──
# ── lumbda asm (bump-only) ──
PID=$(start_server "$ASM < examples/http-server.lsp" 8080)
bench_one "uncommonlisp asm (/bench, 1 KB)" 8080 /bench
bench_one "lumbda asm (/bench, 1 KB)" 8080 /bench
stop_server "$PID"
# ── uncommonlisp asm-gc (naive mark-sweep + meta-GC build) ──
# ── lumbda asm-gc (naive mark-sweep + meta-GC build) ──
if [ -x "$ASM_GC" ]; then
PID=$(start_server "$ASM_GC < examples/http-server.lsp" 8080)
bench_one "uncommonlisp asm-gc (/bench, 1 KB)" 8080 /bench
bench_one "lumbda asm-gc (/bench, 1 KB)" 8080 /bench
stop_server "$PID"
fi
@ -148,9 +148,9 @@ echo
echo "═══════════════════════════════════════════════════════════════"
echo "Binary sizes"
echo "═══════════════════════════════════════════════════════════════"
printf " uncommonlisp asm: %s\n" "$(du -b asm/uncommonlisp | cut -f1) bytes"
[ -x asm/uncommonlisp-gc ] && \
printf " uncommonlisp asm-gc: %s\n" "$(du -b asm/uncommonlisp-gc | cut -f1) bytes (GC_NAIVE build)"
printf " uncommonlisp C: %s\n" "$(du -b c/uncommonlisp | cut -f1) bytes"
printf " lumbda asm: %s\n" "$(du -b asm/lumbda | cut -f1) bytes"
[ -x asm/lumbda-gc ] && \
printf " lumbda asm-gc: %s\n" "$(du -b asm/lumbda-gc | cut -f1) bytes (GC_NAIVE build)"
printf " lumbda C: %s\n" "$(du -b c/lumbda | cut -f1) bytes"
printf " busybox httpd: %s\n" "$(du -b /usr/bin/busybox | cut -f1) bytes (multi-call)"
printf " python3: %s bytes (interpreter binary)\n" "$(du -bL $(which python3) | cut -f1)"