gbtty (pronounced: gib-bit-EE / "gibbity") is a Game Boy (Color) hardware and software project to turn the Game Boy into an ANSI-compatible terminal.

The primary goal of this project is funsies. I wanted to work on a side project where I could use Rust, play around with an RP2040, and do something related to my current hyperfixation: the Game Boy.

Secondary goals include providing a useful-enough implementation of an ANSI terminal, at least to be VT100-compatible to the extent that matters for modern purposes.

Some stretch goals include supporting a broad set of ANSI escape codes, such as text/background color on the Game Boy Color, some support for scrollback, and perhaps even some support for some TUI elements depending on how wild I decide to get with this.

Initially, an attempt at following along rylev's DMG-01: How to Emulator a Game Boy book, I started mixing in some architectural ideas from Yushi Omote's Writing gameboy emulator in Rust and their rgy library. Since both had done such a nice job writing their respective emulators in Rust, I decided to write mine in Go instead.

I don't have any particular goals for it other than have fun writing it, have the source code be generally fairly readable, and keep a relatively straightforward architecture with clear separation between components.

It's currently plays most original, Game Boy games, many Color games, with decent accuracy. It does not yet support audio.

Resumis is Esperanto for "summarized", apparently. Totally coincidental. It's also an API and headless CMS for your personal web presence, a CV generator, and JSON Resume provider.

Aimed at developers & designers, Resumis provides individuals with an API and management interface for their bio, social networks, projects, professional skills, resume, and blog. Resumis offers both JSON-API and JSON Resume compliant APIs to allow for building your own presence using the data from Resumis. (This site is backed by Resumis's API!)

Nearly 10 years ago, I vowed to never rebuild my website from scratch again, and so I've been maintaining the project since 2014 and evolving it to fit my needs as they change.

hcl.cr general-purpose HCL2 (Hashicorp Configuration Language) parser written in Crystal. It does not make any domain assumptions and aims to be spec-compliant and compatible with the Go implementation.

HCL2 support is more-or-less considered feature-complete. However, it does not yet run against the spec test suite, so there may be situations in which some documents do not work as they should or as they work in the go reference implementation. An hcldec implementation is being developed to test against the spec test suite.

It does not yet have full support for some of the more "dynamic" uses supported by the Go implementation, such as certain types of partial evaluation and unknown/dynamic types. i.e. you probably could not build Terraform on top of it, but you could build a nice configuration system for your program.

mstrap (short for "machine bootstrap") is a tool for provisioning and managing a development environment. It is a convention-over-configuration tool, which aims to leverage existing ecosystem tools to provide a one-command provisioning experience for a new machine, and continued management.

Functionality

• Setup Homebrew for development package management
• Install basic development tools and setup reasonable system defaults (via strap or strap-linux)
• Setup environment for running shared, containerized services (currently via Docker)
• Clone and bootstrap projects
  • Automatic setup of web projects with a .localhost domain and locally-trusted TLS cert (via mkcert)
• Setup version-managed language runtimes (via mise, asdf-vm, and/or rustup)

mstrap is wholly centered around proving a no-runtime-dependency (other than normal system libraries) approach and will always remain a tool designed around getting you up and running immediately after taking a new machine out of its box and completing the OS setup.

Over the past few years, I've been slowly chipping away at a point-and-click adventure game a la the old LucasArts & Sierra games. It's a slow moving project, but I'm trying to do as much myself, including puzzle design, writing, pixel art, and programming.

The game stars a private detective investigating a curious case, but beyond that much is up in the air. It's being written from scratch in Rust using the Bevy engine. I'll share more details when there's something to share.

fincher is steganography tool for text. It provides a number of strategies for hiding a message within a source text by storing each character as a typo.

The method by which it works is contingent upon the combination of replacement and displacement strategy. See Usage for more information.

The inspiration for fincher comes from "Panopticon", Season 4 Episode 1 in Person of Interest, in which The Machine encodes a message as typos in the dissertation of one of the main characters, Harold Finch.

fincher is currently 0.3.0 and considered an experiment and a project for funsies. I am interested in any contributions & ideas!

The ClockworkPi DevTerm (A0604 Model) is a Rockchip RK3399-based computer designed for tinkerers and retro-computation fans. It's initially launched with a spin of Armbian but I worked on porting Manjaro ARM (a derivative of ArchLinux ARM) to the device to get it running closer to mainline kernels and newer software. It's now available as a supported device in Manjaro ARM, roughly with parity to the Armbian-based "ClockworkOS".

Work to cleanup the vendor-provided patchsets and get them accepted upstream stalled out, but the Manjaro ARM team continues to maintain support for it, and I occasionally update patches to fix issues with newer kernel versions.

ember-concurrency-retryable is an Ember.js addon that adds retry strategies and a task modifier for automatically retrying ember-concurrency tasks to aids in building fault-tolerant UIs in Ember.js with ember-concurrency..

Stemming from an RFC I opened against ember-concurrency, ember-concurrency-retryable works by wrapping a task's generator function in a try/catch and transparently retrying the generator function in accordance with the passed in retry policy. ember-concurrency-retryable uses generator functions and ember-concurrency primatives like timeout so that it plays along nicely with ember-concurrency like any other task, and remains fully cancelable.

reptyr is a super useful tool written by Nelson Elhage that can be use to move a running process to another TTY session (e.g., moving a process started in the shell to a screen session).

Reptyr currently has support for Linux and FreeBSD using ptrace. macOS, however, lacks a complete ptrace implementation, so does not work with the existing implementation.

I started writing macOS platform support for reptyr based on the FreeBSD code, but implementing it with the needed calls in Mach.

Having an interest in Rust, I stopped working on the macOS support, and instead decided I would port it to Rust and then add macOS support.

Some very early code for macOS support is available here: mf-macos_support

Work on the Rust port is happening here: mf-rust_port