personal projects
projects
databases, compilers, and developer tools.
source code and implementation notes.
storage and queries
Sceptre connects a small SQL layer to a page-based storage engine. tables, primary keys and secondary indexes live in a single file. queries can take a table scan, a primary-key lookup or range, or an exact secondary-index lookup.
inspection and recovery
copy-on-write commits publish through checksummed meta pages. the CLI exposes query plans, traces, B+ tree pages and the freelist. consistency checks and interrupted-commit tests examine what happens between writing a page, syncing it and publishing the new state.
compiler and inspection
ORION compiles ASTRA directly into WebAssembly bytes. the playground links source tokens, the lowered syntax tree, decoded instructions and a hexadecimal view of the emitted module. selecting an instruction highlights its encoded bytes.
browser execution
programs produce canvas pixels and numeric output. compilation and execution run in a disposable worker with cancellation and an eight-second deadline. shared programs compile on opening without running automatically. ASTRA remains a numeric language without arrays, strings or closures.
storage pipeline
Wally writes byte keys and values through a write-ahead log and sorted memtables, then flushes them into immutable SSTables. sparse indexes and Bloom filters support lookups. scans and compaction share a k-way merge that resolves sequence numbers and tombstones.
API and inspection
the public API provides point operations, atomic write batches and range scans. CLI tools inspect the WAL, memtables, SSTables, Bloom filters and manifest. Wally is an embedded storage component; network services and query languages belong to the system using it.
protocol and cache behavior
Blueis accepts TCP clients through a RESP2 codec and command dispatcher. the memory store supports strings and hashes, lazy and active expiration, and noeviction, LRU and LFU memory policies.
persistence and scope
append-only logs and snapshots provide recovery mechanisms. Pub/Sub, INFO and MONITOR expose messaging and server activity. replication uses a snapshot and bounded write backlog; clustering, automatic failover and Redis replication negotiation are outside the supported subset.
concurrent pipeline
directory traversal feeds file-reading workers, which feed CPU search workers and a streaming printer. worker counts can be configured or scaled with the workload, keeping disk I/O and pattern matching in separate stages.
search and configuration
substring, regex and whole-word matching work with .gitignore and project-specific rules. JSON output, predictable exit codes and shell completions make it usable from scripts as well as an interactive terminal.
graph representation and execution
benz focuses on query execution. vertices own their incoming and outgoing edges, while composable pipeline stages handle selection, traversal, filtering, uniqueness and limits through a pull-based, Volcano-style iterator model.
query inspection
queries can be partially consumed and resumed without recomputing earlier results. an explain interface exposes the plan, making it possible to connect a traversal expression to the stages that actually execute it.
HTTP interface
Schlussel stores, retrieves, lists and deletes objects through HTTP. path-like keys map to a filesystem hierarchy, and prefix-based listing provides a way to explore nested namespaces.
keys and persistence
payloads remain binary-safe rather than being transformed on their way to disk. key validation and path traversal protection keep the logical namespace within the storage directory. the scope stays local, without distributed storage machinery.
input and rendering
kilo reads raw input and manages rows of text directly, without external libraries. insertion, deletion, line splitting and merging all feed a custom output buffer that draws the screen using ANSI escape sequences.
editing features
tab-aware cursor positioning, horizontal and vertical scrolling, incremental search and C/C++ syntax highlighting sit on top of those primitives. dirty-state tracking and status messages connect editing to file operations.
game logic
piece generation, rotation with wall kicks, collisions and line clearing form the core loop. scoring, combo multipliers and progressive difficulty give those decisions consequences.
controls and rendering
React state, a requestAnimationFrame loop and keyboard handling connect the game model to the screen. responsive controls support desktop and mobile play, with high scores persisted locally and the application deployed on Vercel.