emberian

please email if any of my open source projects need some love

catch me in matrix? web portal:

i wrote rustdoc, started This Week in Rust, and a bunch of other pre-1.0 stuff highlighted here and chronologged here.

https://github.com/emberian/dregg and https://github.com/emberian/graphplay and https://github.com/emberian/svenvs are interesting.

these coins fund my work:

• dregg (supporting the Dragon's Egg verified hypermedia ecosystem, autonomous agentic development, and machine autarky) https://pump.fun/coin/XkeTXo1125vz5H9svJpGiw4JvLbN8VmMu9cmMvspump

my personal mina address is EKF5Uk95ng6vVHTPCq6bg5f1hjAehJDTAbFYhEHfXg5edXTjGozD

my personal eth address is 0x46d42e1C97299dafC44B857976713dAB464CFF19

my personal sol address is FL8qBdxTMVReqNcU6Qq5ueXeteqPQwKPBqNzMrorJtad

my twitter account is https://x.com/ember_arlynx and https://x.com/DreggNet

open source contribution grab-bag

• Gitalist: Fixed a small error message
• node-tap: Made it ignore certain non-executable files
• sElement: README in https://github.com/Tatsh-archive/sElement
• pillow: import _imaging as core https://github.com/peterhj/pillow/commit/f466def82dfac8f5ec73fc4726cbfc175fe19457
• herbstluftwm: Add help string to herbstclient https://github.com/herbstluftwm/herbstluftwm/commit/0465edbbeabd3dea07510a290b3682aab7c8282f
• trayer-srg: Fix bad format string https://github.com/sargon/trayer-srg/commit/fa1da88ea9a41e25cfa2b1f8be5e92a281c35f83
• sinful.js: Add Array.prototype.partition and rename echo to repeat in js util lib https://github.com/guipn/sinful.js/commits?author=cmr
• jemalloc: Ran clang-analyzer, finding dead code. Independently, also a sysconf edge case
• Vundle.vim: Fixed bad repo url escaping https://github.com/VundleVim/Vundle.vim/commit/84c9a542541d4504deb8eed38f15fe5a2497b6cc
• wsapi: Got into lua a bit, fPIC and linux support in a web library
• ms.c: Some minor stuff in a c library https://github.com/clibs/ms/commits?author=cmr
• http-parser: Wrote a debug tool for node's http parser, also fixed an ipv6 edge case. Also a build status badge https://github.com/nodejs/http-parser/commits?author=cmr. Helped land some pre-HTTP/1.0 support. Abandoned some work supporting "generic" HTTP methods. Added travis ci
• uap-core: Vom'd on a file but fixed it, also taught a list of regex about a new UA
• the_silver_searcher: Taught ag to read gitconfig to find the excludesfile
• Utilities & RequestServer: Worked on some libraries in C (later C++) with a friend for a while. He used it in some game server prototypes. https://github.com/arke-industries/Utilities/commits?author=cmr https://github.com/arke-industries/RequestServer/commits?author=cmr
• playpen: Generated syscalls from headers in a sandboxing tool
• rust-zmq: Some modernization of pre-1.0 rust-zmq, started on some examples
• rustsqlite: Helped upgrade rusqlite when float was removed from rust
• gl-rs, sax-rs, glfw-rs, noise-rs, color-rs, cgmath, gfx-rs: Contributions/general maintainership of several bjz repos, including gl-rs, sax-rs, glfw-rs (now PistonDevelopers), noise-rs (now Razaekel), color-rs, cgmath (now rustgd), gfx-rs. gl-rs was fun, binding generation from XML API descriptions. gfx-rs has changed a lot since I worked on it, but I was once responsible for its (atrocious) texture/image API!
• multibuilder: For is rust slim yet, some multibuilder fixes
• apitrace: Fixed a bug that prevented tracing core profile apps on linux
• hammer.rs: Some work on an old option parsing library for rust
• cargo: Taught cargo about per-platform config locations although github seems to have lost the commit range?
• glfw: Enabled ASLR
• iron (urlencoded, persistent, logger, staticfile): Some small contributions to iron repos, eg, eg eg eg eg eg there are more not really worth linking!
• lazy-static.rs: Doc fix
• xml-rs: Helped bring xml-rs into the new world
• hyper: Added If-Modified-Since header support
• winapi-rs: d3d9 support
• lapack-sys: LAPACK bindings
• blas: Complete BLAS bindings
• lapack-sys: Designed reasonably pluggable (at the time) BLAS/LAPACK backends
• pool: Fixed some unsafety in a data structure
• glutin: Abandoned some joystick support
• bitflags: Made a nice bitflags Debug repr. This got a bit more complex over time!
• nix: Did some cool ioctl work for nix (not that nix). This replaced an earlier crate I maintained for doing ioctl that I'm still quite proud of. It generated bindings from the kernel headers. Great for Linux, not great for others. ioctl are a mess.
• VisualRust: Created VisualRust. Added a basic syntax highlighter using the lexer I built during my Mozilla internship. Thankfully vosen, an experienced C# dev, took over the project. Abandoned a toolchain downloader/updater though
• Rust: The Great Relicensing. Wrote about this here
• sample: Made the sample crate, for audio processing able to be used without an allocator/std
• easyply: Some fixes to easyply, a python lex and yacc helper library. Used it at Data61 during my co-op
• byteorder: Made the byteorder crate usable in no-std
• serde: serde no-std
• xmas-elf: xmas-elf no-std
• spin-rs: Added manual unlocking to spin-rs for FFI
• seL4: Tweaked a magic number
• ArkeOS: Same friend as earlier doing game stuff, this time with a fictional computer. Made it run on mono in linux.

Ember's projects, partial (from starmap summaries)

_200 ember-authored repos summarized by Gemini, grouped by category. Reference for domain skills + overview. Source: ~/dev/starmap._

2D Game Engine Integration

• connectfour — A cross-platform implementation of the Connect Four game using the Simple and Fast Multimedia Library (SFML). The project features a custom board state manager with win-condition detection algorithms for horizontal, vertical, and diagonal alignments. It employs a decoupled architecture separating the graphical rendering loop, the grid-based game logic, and the event-driven user interface. _(sfml, cpp, game-development, connect-four, 2d-graphics, board-game)_

3D Asset Design & Digital Fabrication

• rust-logo-3d — This repository provides high-fidelity 3D geometric representations of the Rust programming language logo. It includes source assets in Blender's native format and exported STL meshes, enabling seamless workflows for 3D printing and digital rendering. The models accurately preserve the intricate gear and letterform topology required for consistent brand reproduction across physical and virtual environments. _(3d-model, rust-lang, blender, stl, 3d-printing, brand-assets)_

AI/Agents

• crate-mcp — crate-mcp appears to be a ai/agents project using Rust. The available files suggest focus areas around cargo, main, readme. _(Rust, cargo, main, readme)_

API Integration Testing

• github-api-testing — A skeletal environment dedicated to the empirical validation of GitHub API endpoints and authentication mechanisms. The repository functions as a minimal testing harness for investigating RESTful interface behaviors and verifying API client configurations within a controlled environment. _(github-api, integration-testing, rest-interface, api-validation, scaffold, placeholder)_

AVR Bare-metal Firmware

• arduino-display — A collection of low-level AVR C firmware routines for driving multiplexed four-digit seven-segment displays via direct register manipulation. The project implements hardware-specific bit-masking and GPIO control using Atmel's Data Direction and Port registers to manage segment illumination and digit switching. It includes various test patterns for binary counting, character rendering, and manual multiplexing logic. _(avr, firmware, c, seven-segment, gpio, multiplexing)_

AVR Embedded Systems Development

• homie — A first-principles cleanroom Rust toolchain and no_std runtime specifically targeting the ATmega32U4-based Arduboy game platform. It implements low-level hardware abstractions for GPIO-mapped peripherals including the OLED display, RGB status LEDs, and tactile button matrix. The project provides a workspace-based architecture for developing firmware with direct register access and custom panic handlers suitable for 8-bit AVR microarchitectures. _(avr, atmega32u4, arduboy, rust, embedded-rust, no-std)_

Aerodynamic Sports Simulation

• friskingdom — Friskingdom is a modular Ultimate Frisbee simulation engine developed in Rust using the Bevy ECS framework, prioritizing authentic disc aerodynamics and wind-field interactions. The architecture decouples core physics from strategic AI behavior and procedural audio synthesis, which includes a custom subtractive synthesizer for real-time sound generation. It features a comprehensive rendering pipeline for stylized stickman animations and dynamic field environments, supported by a suite of developer tools for system debugging and asset generation. _(frisbee, physics-engine, bevy-engine, ecs, aerodynamics, ai-simulation)_
• frisqueendom — Frisqueendom is a sophisticated 3D sports simulator centered on ultimate frisbee mechanics, utilizing a custom aerodynamic physics engine written in Rust and compiled to WebAssembly for high-performance flight calculations. The project integrates complex team AI behaviors, procedural skeletal animations, and a multi-layered career management system within a Three.js-based rendering environment. It supports local and LAN multiplayer via a custom relay protocol and features extensive automated testing for both physics integration and gameplay logic. _(ultimate-frisbee, aerodynamics, physics-engine, webassembly, three-js, rust)_

Affective Speech Synthesis & Broadcast Automation

• chetgpt — A specialized AI news anchor application that emulates the Chet Ubetcha persona from The Fairly OddParents through dynamic speech synthesis. It integrates content analysis with the Qwen3-TTS engine to automatically select from eight distinct prosodic modes, ranging from breaking news urgency to tragic gravitas. The system combines real-time news aggregation, LLM-driven chat capabilities, and ASCII-based visual feedback to provide a cohesive broadcast simulation. _(text-to-speech, voice-synthesis, qwen-tts, news-aggregator, cli-application, natural-language-analysis)_

Agent-based Colony Simulation

• pinatatown — Pinatatown is an agent-based colony simulation engine developed with Phaser 3 and TypeScript, featuring a sophisticated goal-oriented AI system that governs autonomous entity behaviors through personality traits and perception modeling. The architecture employs an isometric world representation with A* pathfinding, dynamic zone management, and a modular system approach for handling farming, construction, and seasonal environmental cycles. Subsystem communication is orchestrated via a central event bus, enabling emergent gameplay through complex relationship dynamics and predator-prey interactions. _(Phaser 3, TypeScript, Colony Simulation, Agent-based AI, Isometric Engine, A* Pathfinding)_

Agentic Game Design Orchestration

• neocadia — A narrative-driven minigame collection built with Phaser and TypeScript, featuring a sophisticated multi-agent design orchestration system. The project utilizes specialized AI personas—including Creative, Systems, Narrative, and UX Directors—to iteratively refine game specifications and mechanics across diverse thematic zones. It implements a structured ecosystem of arcade-style loops integrated via a central economy and meta-progression framework. _(phaser-3, minigame-collection, narrative-design, game-economy, ai-agents, automation)_

Algorithm Design and Analysis

• cs344 — A comprehensive implementation of core data structures and algorithms, featuring comparative performance analysis of sorting techniques and balanced tree structures. The project includes robust implementations of BST, AVL, and Splay trees, along with graph traversal algorithms (BFS/DFS) and specialized min-max selection routines. _(data-structures, algorithms, cpp, sorting-algorithms, binary-search-trees, avl-trees)_

Android MVVM Architecture

• didijustdrinkwater — A native Android hydration tracking application implementing modern architectural patterns with the Jetpack suite. It utilizes Room for local SQLite persistence of timestamped events, Kotlin Coroutines and

…

Collapse