Projects

19 projects · click a card to expand
SEANCE
SEANCE stands for Sound Exploration And Node-based Composition Environment.
https://github.com/inhahe/SEANCE
Made with Claude Opus 4.6/4.7/4.8
Made in C++, uses JUCE
It's meant to be more intuitive/self-explanatory than other DAWS for beginners at music and DAWs, using plain words, generalization rather than a swamp of specifics, and lots of
tooltips.
All audio and control flow is explicit/visible, none of it is hidden or magical.
  • Supports non-native plugins and instruments:
    • Instruments & effects: VST3, AU, LV2, LADSPA, and WASM modules (that are made specifically for SEANCE)
    • Instruments: SF2 and SFZ
  • Anything that that's modulable can be modulated either manually or by signals, which can be determined by user-inputted program/expressions, by plugin output, by pre-created repeeating waveforms, by the user manually using the mouse (in either 1D or 2D) or MIDI controller knobs/sliders, or by any combination thereof.
  • Any kind of waveform/curve anywhere can be defined by program/expression, by editing by hand as curves or freestyle or by loading from the library, and AHDSR curves can additionally be defined by individualal sliders.
  • Full undo+redo trees
  • Supports N-dimensional wavetables:
    • Grid-based or scatter-based
    • Can be viewed in 2D or 3D and rotated on any axis
    • All wavetable voices can also be used as individual instruments via saving to/loading from the library, and vice versa for the subset of instrument types that can also be wavetable voices.
    • Various ways to create your own voices:
      • Grains - capture from audio (microphone/line-in, playing the project, or audio file), with the choice of 4 different freezing algorithms with optimization parameters
      • Create or load arbitrary curves:
        • In the time domain, using any number of constituent waveforms that add up, each of which is modulable:
          • Harmonic waveforms, where you can specify the harmonic multiple for each waveform, and any waveform not without an LFO associated with it (i.e., not chosen to be modulable) will be added up at creation time rather playback time
          • Inharmonic waveforms
          • Both harmonic and inharmonic constituent waveforms can either be of the kind where modulation defines the waveform, or the kind where modulation only alters the waveform (in phase or amplitude).
        • In the frequency domain
        • In the wavelet domain
    • All wavetable voices can have an arbitrary stack of independently modulable waveform-manipulation algorithms, of which there are 20 to choose from.
  • Supports N-dimensional amplitude terrains, where you can import terrains from video, image or audio or define them via programs/expressions.
  • Supports per-note polyphonic subgraphs, like Bitwig's Poly Grid
  • Supports Python scripting to create MIDI tracks, node graphs, etc.
  • Supports input from any number of simultaneous MIDI controllers but can also use the keyboard or mouse
  • Supports 4 separate temperaments, as well as a custom reference frequency with 8 built-in standards, all of which apply to non-native plugins as well.
  • Uses roots, keys, modes and scales (32 of them)
  • Scripting various things (including LFOs) variously supports Python, Lua, WASM, GLSL, and and/or the built-in language. Some feature+language combinations allow two modes of scripting: entering an expression, or entering a whole program which owns the loop. (See SCRIPTING-LANGUAGES.html.)
  • Supports lane comping
  • Modulable EQ - you specify a number of curve points, and then each one's X-Y positions can be modulated. Has two options for EQ algorithm: one for accuracy, one for latency.
  • Spectrum analysis-to-LFO:
    • Type 1: You specify arbitrary, possibly overlapping frequency bin positions and widths that each output an LFO signal.
    • Type 2: For each LFO output, you define an arbitrary curve over the whole spectrum, where the output is the dot product of the curve and the current spectrum analysis.
  • You can cache the audio stream at any graph point for subsequent runs for more CPU-efficient playback for the case when nothing upstream of that point is expected to change.
  • Supports convolution filters with combining successive convolvers into single convolvers for better CPU efficiency and latency (4 built-in filters plus custom import/draw a filter; < 1024 samples → direct time-domain convolution, ≥ 1024 samples → partitioned FFT overlap-add)
  • Wavelet technology
  • 4,000+ built-in waveforms
  • Audio, LFO & MIDI transformation plugin that can take arbitrary mathematical expressions to tranform signals and can use any number of input and output audio, LFO and MIDI signals
  • Can do triggering, harmonizing, note repeating, note delaying, and humanizing/probability in one native plugin
  • Can record all modulations of all plugins, including VST3/AU/etc., for playback the next time the project is played
  • Can record input from any number of mics/line-ins
  • Can wire any MIDI controller knob/slider to any modulable parameter, supports MIDI Learn
  • Can import XM, IT, S3M, and MOD tracker files - converts them to the native DAW flow for full editing ability (not made for saving back to tracker format - the genie can't be put back into the bottle)
  • MIDI timelines can be children of other MIDI timelines, to any degree of nesting, each with a specific time offset relative to its parent (supports time anchors so that child offsets move left or right in time if we cut out time or insert time in the parent upstream of the offset).
  • Configurable/resizable spectrum analyzer view, oscilloscope view (traggered and roll modes), and spectrogram view
  • Includes 16 built-in instruments (not including the SF2 and SFZ loaders), 35 built-in audio effects, and 4 built-in MIDI-input/output effects
fastpy
Python compiler
https://github.com/inhahe/fastpy
Made with Claude Opus 4.6/4.7
Made in Python and Rust; works in Windows and Linux; uses llvmlite
Fully CPython 3.14-compatible
  • Supports native modules (.pyd, .so) and a few of the more advanced Python constructs through a CPython bridge
  • Has been tested using:
    • The Python test suite
    • The Django test suite
    • Django with a random middle-ware plugin
    • pyperformance
    • AI-generated test suite(s)
    • An AI-generated fuzzer
    • Compiling and running itself, for the part that's written in Python
    • Compiling every standard module written in Python with fastpy and then using the test suites against the compiled modules
  • Can force various optimizations on or off for specific things with annotations
  • CLI option to treat all numbers as 64-bit ints without bignum fallback for speed, plus CPython shim to make it compatible with fastpy when using that CLI option
  • Performs tight loops and function calls 140-173x as fast as CPython; float mat, recursion and dicts 14-50x as fast as CPython; methods, containers, strings and obects 3-20x as fast as CPython
Lithic Backup
Backup software for Windows
https://github.com/inhahe/Lithic
Made with Claude Opus
C#
Made for a few specific features I wanted in a backup program
  • Backup to optical media or directory
  • Optical media (untested, but incudles simulation and simulated failure modes for testing):
    • Automatic zipping for incompatible paths
    • Remembers which files are in which discs
    • Can integrity-check a disc and re-burn affected files if the disc fails
    • Automatic disc spanning for files too large to fit onto a single disc
    • Bin-packing
    • Automatic consolidation: when a backup set accumulates too many incremental discs (configurable threshold, default 5), LithicBackup repacks everything onto fewer optimally-filled discs — keeping the set manageable
    • Post-burn verification
    • Capacity overrides: override the reported disc capacity for media that over-reports (common with M-Disc)
  • Optional file-level and block-level deduplication, with configurable block size
  • Supports a list of paths/filenames to exclude from the backup with path/filename masks
  • Version retention - supports any number of version-retention tier-sets, each tier-set with a list of paths/filenames masks to retain and any number of tiers each specifying maximum number of days to keep N number of past file versions
  • Scheduled or continuous backups
  • Backs up files and directories with the original directory structure and filenames except when changing file extensions for deduplication
  • Source selection:
    • Treeview file browser with tristate checkboxes — select entire drives, individual directories, or specific files
    • New subdirectories are automatically included for parents with "Auto-include new" selected
    • Pre-backup size calculator - caches backup size for each subdirectory and shows sizes in treeviews
  • Restore:
    • Browse backed-up files in a checkbox treeview of directories and files to restore
    • Handles all storage formats transparently: plain files, split files, zipped files, file-deduplicated, and block-deduplicated
    • Multi-disc restore with guided disc insertion prompts
    • Per-drive destinations: backups spanning multiple drives can be restored to multiple destinations, with one editable target folder per source drive — or restore everything back to its original location in one click
    • Preserves original directory structure under each destination
    • Restore Without Catalog (disaster recovery)
  • Cleanup feature: a single unified view that surfaces files and directories worth removing across the catalog and the backup destination.
  • Can copy backup sets
  • Can edit backup sets
  • Can change a backup set's destination
  • Can seed a backup set catalog from an existing backup
  • Can backup multiple sets concurrently
  • Can verify backup integrity
  • Right-click context menu on backup sets
  • Drive-letter resilience: automatically detects when an external drive changes its drive letter
  • Memory budget: directory backups can read each file from disk only once, buffering its contents in RAM to serve both the deduplication analysis pass and the actual write (instead of re-reading it), using a configurable max amuont of ram (defaults 50% of total RAM but always leaving at least 2GB free)
  • Diagnostic & crash logging
4djulia
3DJulia
Shows 2D planes or 3D hyperplanes of the 4D julia set
https://github.com/inhahe/3djulia
https://julia4d.html
Made with Claude Opus 4.6
There's C++ version and a web version (the web version does more, IIRC)
  • Rotate 2D plane or 3D hyperplane on any 4D axis
  • Can choose complex calculation or quaternion calculation
  • Includes a novel "chessboard" mode for 2D invented by me
ultimate color picker
Ultimate Color Picker
https://github.com/inhahe/colorpicker
https://colorpicker/
Made with Claude Opus
HTML/CSS/JS
Can arbitrarily move, create, delete, and snap together feature panels, automatically saves layout, and can export or import layouts.
  • Supports 10 color models (one of them made-up)
  • 3D histogram view within currently selected color model
  • Plain, sterescopic (cross-eyed or wall-eyed) and 3D glasses (4 different 3D glasses colors) views of color models and histograms
  • View of the currently selected color's model coverage with respect to CIE 1931 xy chromaticity horseshoe
  • Can create a 256-color palettes for rotating, using sophisticated tools (such as by dragging the mouse along a path on the 2D color swatch, increasing or decreasing the speed at which the palette consumes pixels by scrolling the mouse wheel)
  • Supports saved colors, color history
  • Can mathematically rotate the controls of the current color model by arbitrary degrees by dragging the orientation of its 3D view
  • Comes with an eyedropper
  • Supports ICC profiles
  • Can create a custom color gradient or color triangle from the 2D swatch view
bouncing glyphs
Bouncing Glyphs
https://github.com/inhahe/shapes
https://bouncing_glyphs.html
Made with Claude Opus
Python version (rudimentary), web version
Something I'd been wanting to make for decades, but never had the physics or computer science expertise to do so. And now that it's made, I never cease to be entertained and titillated by it.
  • 2D & 3D modes
  • Use any font installed on the system or load an arbitrary font file.
  • Set a string containing all characters to use from the font, or use one of five pre-defined character sets.
  • Optional soccer-like goal that eats glyphs and momentarily spit out new glyphs while conserving kinetic energy (works in both 2D and 3D mode)
  • Can specify friction, gravity between glyphs, gravity toward the ground, number of glyphs, glyph size, glyph depth (for 3D), gravity law (2D or 3D), colors, goal width, depth (for 3D), perspective (for 3D), depth color range (for 3D), and more.
  • Plain view, stereoscopic view (cross-eyed or wall-eyed), or red-cyan glasses view - can specify distance between eyes, distance from screen, and DPI
  • Glyphs bounce off each other according to their actual exact contours and masses.
grep
grep.py
https://github.com/inhahe/grep
Python version made by me (except for one function made with Claude Opus), C++ version made with Claude Opus
Written since I couldn't find a version of grep for Windows that supported traversing subdirectories and also didn't hang or crash or have a certain quirk where not all regex expressions worked right
  • Supports -r for recursion
  • Can specify multiple directories and/or filename masks to search through
  • Can specify subdirectories and/or filename masks to exclude
  • Can specify multiple regexes, all of which have to match within a specified number of lines of each other in the file
  • Has colored output, and you can define and persist custom colors or disable them
  • Can specify case sensitivity for filename matching
  • Escape-code sanitizing display
  • Symlink-aware recursion distinction
  • And most of the features standard grep supports
orchestrator
orchestrator
https://github.com/inhahe/orchestrator
TUI Claude Code replacement
Made with Claude Code 4.6
Python
  • Shows single lines for thinking blocks, tool uses, background commands, etc., with commands for viewing details for any of them, plus optionally expand all of them by default
  • Prompt queue (visible under the toolbar) with delete function
  • Toolbar shows current state (idle, working, etc.), estimated context size, number of turns, current Anthropic plan, effort level, thinking (on, off), number of background tasks running, and number of items in Claude's itinerary
  • Options to show list of currently running background task and/or Claude's itinerary underneath the toolbar
orchestrator2
orchestrator2
https://github.com/inhahe/orchestrator2
Web-based Claude Code replacement, Python backend
Made with Claude Code
Python backend, HTML/CSS/JS frontend
  • Shows single lines for thinking blocks, tool uses, background commands, etc., by default, expandable/collapsible by clicking, and also collapses successive thinking, tool, and background command lines into single lines after they're no longer within the current turn
  • Toolbar shows current state (idle, working, etc.), number of turns, Anthropic plan, model, effort level, thinking (on, off), estimated context size, and rate limit alerts
  • Left panel shows prompt queue (each prompt editable, plus the option to merge them all into one prompt), currently running background tasks, and Claude's itinerary
DirtyFork
DirtyFork BBS
https://github.com/inhahe/DirtyFork
telnet://inhahe.com:23
Overall structure coded by me, details filled in by Claude Opus
Python
  • YAML configuration for everything
  • Forums and private messages:
    • Supports editing with or without word wrap
    • Sends more or less the minimal amount of ANSI possible for any given screen update
    • Supports Gmail-like nested left |'s (or alternatively <'s) and accompanying keyboard navigation for changing levels, inserting lines between or deleting them
  • 16-bit door game support using DOSBox or DOSBox-x
  • 32-bit door game support
  • Can show system message windows over door games that restore the original screen after they're closed, using internal ANSI emulation of the door's output
  • All configuration strings support recursive variable substitution with cycle detection
  • Teleconference
  • One-on-one chat from anywhere in the BBS that shows what each user is currently typing
  • File library:
    • Supports tags rather than a hierarchical directory structure
    • Supports ZMODEM and YMODEM
  • MBBS/WG-style paging
  • Real modem support (untested)
  • And more
Snafu
Esoteric programming language intended for code golf
https://github.com/inhahe/Snafu
Made with Claude Opus
  • Very terse syntax for everything, including backtick lambdas + one-letter aliases
  • Infinite meta-circular interpreter stack - The interpreter is a Snafu variable. You can modify it — and modify the interpreter that interprets the interpreter, ad infinitum. (Recursion level is set at the top of the program.)
  • N-dimensional instruction pointer
  • Fork the universe
  • INTERCAL's comefrom — reverse goto
  • APL-style array operators
  • Algebraic effects with resumable continuations
  • Program history and rollback
  • Reactive variable triggers
  • Logic variables + constraint solving
  • Forth-style stack mode
  • Function inverse — algebraically derived
Wicket
IRC bouncer
https://github.com/inhahe/Wicket
Made with Claude Opus
Python
Made because of frustractions I had with ZNC
  • Multi-user, multi-network
  • Everything configured in a single YAML file, with cascading configuration - top level, per-user, per-network - nick, realname, rate limits, capabilities, replay behavior, etc.
  • Login password format identical to ZNC's
  • Per-device history playback - similar to ZNC's but without the need to find and compile an external module - with persistent SQLite history.
  • IRCv3 capability negotiation
  • SASL support
  • TLS support
  • Built-in ident server (optional)
  • Per-server rate limiting (burst rate + sustained rate)
  • Auto-reconnect with multi-server failover.
  • Live rehash. Reload the config file without dropping connections.
  • In-band control. Manage the bouncer over IRC by messaging *wicket.
  • Activity replay. Optionally replay channel JOINs/PARTs/KICKs/MODEs/ NICKs/QUITs that happened while you were away, with per-channel overrides.
qtpyrc
Cross-platform IRC client
https://github.com/inhahe/qtpyrc
Overall framework made by me, the rest filled in with Claude Opus
Python
  • IRCv3 support: CAP negotiation, SASL (PLAIN/EXTERNAL), message tags, server-time, typing notifications, BATCH
  • Token-bucket flood protection with configurable burst and rate
  • Multiple server support per network with automatic cycling on failure
  • Bouncer-friendly: handles playback batches (ZNC, chathistory)
  • Tabbed or MDI (free-floating window) view modes
  • Multi-row tab bar with network grouping and activity indicators
  • Network tree sidebar (tabs, tree, or both)
  • Configurable toolbar with SVG icons
  • Color picker with RGB, HSB, HSL, L*a*b*, and L*C*h* color spaces, eyedropper, and saved colors
  • Font picker with live preview
  • mIRC color code rendering (16 + extended 99-color palette)
  • Searchable chat output (Ctrl+F) with regex support - current window or global (Ctrl+Shift+F)
  • Inline link previews with Open Graph thumbnails (opt-in, proxy support)
  • YAML config with 3-level cascading: global > network > server/channel
  • Settings dialog with live preview for fonts and colors
  • Integrated file editor for config, toolbar, popups, startup scripts, and variables
  • Per-network identity, flood control, SASL, and auto-join overrides
  • Per-channel ignores, auto-ops, highlights, and notification control
  • Python plugin API with full access to IRC events and client state
  • /exec for inline Python evaluation
  • /on event hooks with pattern matching, sounds, and desktop notifications
  • /timer for recurring commands
  • Startup command scripts
  • mIRC-compatible popup menus (right-click context menus for nicks, channels, tabs)
  • Desktop notifications and sound alerts per event type (highlights, queries, notices, connect/disconnect)
  • Nick notify list with ISON polling (online/offline alerts)
  • Highlight patterns with regex support and {me} substitution
  • Per-channel notification suppression
  • Headless mode (--headless) for running bots and scripts without a GUI
  • Channel history replay from SQLite database
  • IRC log files with optional per-network and per-channel subdirectories and monthly rotation
  • URL catcher
  • Built-in ident server
  • Persistent user variables (/set)
  • Tab-completion for nicks with recency sorting
  • Command-line parameters to go straight to any configuration dialog, toolbar entry or menu entry
  • Commands to jump to a specific window on a specific network or say something in one, e.g. /window undernet/#philosophical
Pocket IRC
Mobile IRC for Android
https://github.com/inhahe/PocketIRC
Made with Claude Opus
Kotlin
  • Multi-network with auto-reconnect, per-server token-bucket rate limiting
  • App-wide default identity (nicks, real name, username) with per-network overrides
  • SASL PLAIN, server PASS, IRCv3 message-tags, MONITOR / ISON notify list
  • Mention, PM, and notice notifications with inline reply (reply directly from the notification without opening the app); notify-list online/offline notifications.
  • A separate /alert and /on-hook notification system routed through any number of user-defined channels with configurable sound, vibration, lights, and badge per channel.
  • Tablet/landscape persistent split layout (server tree + chat + nick list)
  • Searchable, exportable per-buffer history persisted in Room
  • Channel info screen with mode flags, ban / except / invite / quiet lists
  • /list channel browser, /who, /whois reply routing back to the originating buffer
  • /on event hooks (chanmsg, privmsg, join, part, quit, kick, nick, etc.) with nick mask, channel, network, and text-pattern filters and {var} / $var substitution. Supports -d (notification), -s (sound), -x (suppress default), -p (persist across restarts).
  • Editable startup script run at app launch
  • mIRC color and formatting input via long-press send / leading icon
  • IPv4/IPv6 family pinning per endpoint with custom TLS hostname verification
  • No analytics, no tracking, no Google Play Services
StartMe
A modern Startup Delayer-like program for Windows - Reads all of Windows' startup app launching entries and replaces Windows' automatic launching with its own
https://github.com/inhahe/StartMe
Made with Claude Opus
Python
Made because Windows annoyingly sometimes quits the entire auto-launch queue if you do too much activity while it's auto-launching and also annoyingly has several different places in which auto-launches are defined
  • Sequential launching — Programs start one at a time with CPU idle detection, so each app finishes loading before the next begins
  • Multi-column UI — Automatically arranges entries into columns based on screen size
  • Drag-and-drop reordering — Drag entries to control launch order
  • Block persistent apps — Some apps re-add themselves to startup every time they run. The block feature re-suppresses them on every boot
  • Per-session skip — Right-click to skip an entry for this session only
  • Start now — Right-click to launch any individual entry immediately
  • Error reporting — Failed launches show the error message inline and on hover
  • Settings — Configurable column width, launch delay, auto-close behavior, overlay/desktop mode
  • Overlay or desktop mode — Run as a borderless always-on-top overlay, or as a normal desktop window with taskbar entry
  • UAC elevation — Installs with admin to suppress HKLM and WOW64 startup entries
TrayMinimizer
Command-line program for Windows to start any given app and force it to load in the system tray instead of the taskbar
Made with Claude Opus
Python
  • Add already-running app
  • Launch minimized app's UI
  • Restore all
scribbles3
Graphical thing I'd wanted to make for many years but never knew how to, then eventually figured it out. I used to hand-draw things that looked pretty much exactly like this in school when I was bored.
https://github.com/inhahe/scribbles3
https://em.html
Not made with AI
C++
  • CLI options to create seamlessly looping version and save to animated GIF
  • Various tuning parameters
DictionaryGraph
A full graph-based analysis of Webster's 1913 dictionary and WordNet
https://github.com/inhahe/dictionarygraph
Made with Claude Code
Python
  • Total words (nodes)
  • Total edges
  • Avg edges per word
  • Self-ref examples
  • Ranks, sizes, %s of total, sample words
  • Component size histograms
  • Directed BFS from "apple" - Max depth to reach all reachable words (depths 1-10):
    • Depth
    • New words
    • Cumulative
    • % of total
  • Undirected BFS from "apple" (depths 0-4)
  • Island Fragmentation (unexplored territory at each directed BFS depth; depths 0-10)
  • Strongly connected components:
    • Total SCCs
    • Non-trivial (size>=2)
    • SCC size distribution
    • Top 10 SCCs
  • Shortest definitional loops
  • Counting ALL mutual-definition pairs (2-cycles):
    • Total 2-cycles in dictionary: 45,446
    • Sample pairs
  • Longest definitional loops
5drotate
Loads an image and treats every pixel as a 5-dimensional point made from its 2 x-y coordinates and its 3 RGB values, then allows you to arbitarily rotate it in 5D
https://github.com/5drotate
Made with Claude Code
HTML/CSS/JS
  • Configurable:
    • RGB mode or HSV mode
    • Dot size
    • Zoom (can use scroll wheel to zoom)
    • Ratio of color depth to spatial extent
    • Magenta / Black / Clamp toggle for out-of-gamut pixels.
    • Rotation sliders for all 10 axes
    • Randomize rotation
    • Animate rotation randomly
    • Reset all
  • Export PNG