Projects

35 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, the compiler optimized with Fable 5
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
GPDA
Generalized Push-down Automaton
https://github.com/inhahe/GPDA
Basic algorithm invented by me; implementation and a couple of tweaks done with Claude Opus.
It's a novel idea for a parsing algorithm. This algorithm shares aspects with Earley, GRL, and LR(0) (none of which I knew about when I invented it), but this one is more elegant, simpler, and more capable, or at least it is more than some of those. Can use EBNF or a home-made BNF/EBNF/PEG variant that I made up called EPEG.
Python, C++
  • Runs nearly as fast as BISON
  • Scannerless or tokenized — pick your trade-off. Both use the same one-file unified EPEG syntax (no lexer-file / grammar-file split either way). Scannerless additionally gives you context-aware lexing (different skip rules in different grammatical contexts); tokenized is a few times faster in steady state because it parses tokens, not characters.
  • Regex-style terminals with /pattern/flags — flags i (case- insensitive), x (verbose, strip whitespace and # comments), u (Unicode; UTF-8 byte-level in the scannerless form, Python re Unicode flag in the tokenized form).
  • Character classes [abc], [^abc], [a-z], shorthand classes \d \w \s. Unicode ranges under /u decompose to UTF-8 byte patterns ([\u4e00-\u9fff] works).
  • Quantifiers * + ? with greedy / non-greedy forms, bounded {n,m} / {n,} / {,m}.
  • Alternation with ordered choice — the first alternative listed wins at ambiguous forks (no precedence declarations needed for simple disambiguation).
  • Predicates &(expr) / !(expr) for zero-width positive / negative lookahead.
  • Named captures name:=(expr) and backreferences to capture names (scannerless).
  • Semantic actions {{ python_expr }} at the end of any alternative (Python only; the C++ emitters reject grammars using them).
  • Grammar-level directives: @skip (auto-insert a whitespace-like rule between elements), @atomic (disable auto-insert for a rule), @longest (commit to longest match for a DFA-compilable rule), @keyword (append !wordchar to keep a keyword from matching a prefix of a longer identifier), @mode (partition skip rules so different grammatical contexts see different skip sets), @left / @right / @nonassoc (precedence declarations for binary- operator rules).
  • ISO 14977 EBNF mode — load_grammar(text, ebnf=True) parses the grammar as strict ISO EBNF (= ; , | [] {} ()), with the A - B exception operator supported via a length-bounded sub-parse.
  • Direct and mutual left recursion — handled by a grammar rewrite pass + post-hoc tree reconstruction.
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
  • When the user moves or renames files or directories in the sources, Lithic just moves or renames the corresponding files or directories in the destination rather than re-copying them.
  • When an external drive changes drive letters, Lithic tracks it via volume GUID
  • 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
  • Can remap a source drive in a catalog to a different drive in the actual sources with the same directory structure/files
  • 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
LanLink
Program similar to EasyJoin for mobile (Android) and desktop (Windows)
https://github.com/inhahe/lanlink
Made with Claude Opus
C#
  • Auto-discovery: all instances on the same LAN find each other automatically (UDP broadcast)
  • Text messaging: send text instantly between devices
  • File transfer: send single files or entire directories with live progress
  • Remote connect: connect to any instance over the internet by entering its IP/domain
  • LAN bridging: if any device on your LAN connects to a remote device, all LAN devices can see and send to all devices on the remote's LAN — multi-hop relay with loop detection
  • Auto-accept: received files save to a configurable download folder
  • Drag & drop (desktop): drop files/folders onto the window to send
  • Zero configuration: works out of the box, no accounts or pairing needed
Good Photons
Forward ray tracer
https://github.com/inhahe/GoodPhotons
Made with Claude Opus 4.8, debugged some and optimized with Fable 5
Python, C++
  • Spectral transport — single-wavelength photons over a configurable band (e.g. spectral 360 830 1); per-wavelength refraction gives dispersion and chromatic aberration with no extra code.
  • Forward and backward engines that validate each other (mode V reports the residual between them).
  • Realistic cameras — from a simple pinhole to a physical multi-element lens (real glass prescription: depth of field, vignetting, spherical & chromatic aberration all emergent), plus fisheye/panoramic projections.
  • Rich material set — dielectrics with real glass dispersion, metals from measured data, rough microfacet, thin-film & multilayer interference, diffraction gratings, fluorescence, and stochastic mixes.
  • Built-in light envelopes -
  • Wave-optical effects — thin-film Airy interference, Abelès multilayer stacks, and reflective diffraction gratings.
  • Participating media — homogeneous fog with Henyey–Greenstein or Rayleigh scattering - can specify blobs of fogs as functions of [x,y,z]
  • CUDA GPU backend for the forward pinhole splat (mode B), megakernel or wavefront, with CPU fallback.
  • Long-running renders — time / noise / forever budgets, live ANSI preview, and checkpoint/resume.
  • Can define any number of cameras in one scene, useful for simulating camera motion through a scene with a single render (but only speeds things up for modes A and B) - supports defining ribbons of cameras defined by 3D curve points and also points determining a curve in density of cameras over curve length
  • Supports 12 shape primitives, plus arbitary-function isosurfaces
  • Can define a few material properties via functions given their x, y, z coordinates
  • Has its own scene-description language plus support for Mitsuba XML
  • Render modes:
    • Finite-lens camera - Forward next-event splat through a finite aperture + thin lens (true depth of field, efficient) - CPU + GPU
    • Pinhole splat (default) - Light-tracing splat to a pinhole camera; independent photons - CPU + GPU
    • Finite-aperture catch - Forward photon catch through a thin lens (real depth of field) - CPU + GPU
    • Backward reference - Backward path-traced reference image; drives the physical-lens camera - CPU + GPU
    • Validate - Runs B and R and reports the best-fit residual between them - CPU (+GPU forward pass)
    • Composite - Forward B for diffuse/caustic pixels + a backward camera ray for specular/coated surfaces - CPU + GPU
    • BDPT - Bidirectional path tracing with MIS over every light×camera connection - CPU + GPU
  • Cameras:
    • Basics: eye, look_at, up, fov_y, mode, and a film { res N M … } block. Film size can be a preset format — full-frame, aps-c, micro-four-thirds, super35, medium-format, 6x6, 6x7, large-format, 4x5, 8x10 — or an explicit size W H in millimetres.
    • Projections (projection …): rectilinear (default perspective), equidistant and equisolid fisheye, stereographic ("little planet"), and orthographic. These are analytic remaps available in the forward pinhole mode.
    • Analytic depth of field: aperture, focus, lens (focal length, mm), fstop, and zoom give a thin-lens camera with a real focus plane and bokeh. This is the fast, approximate option: an ideal paraxial thin lens with a circular aperture, evaluated analytically, so it runs in the forward modes (B splat / C catch) with no per-element ray tracing. It gives correct focus-plane placement and blur size but no optical aberrations (no spherical/chromatic aberration, distortion, or field curvature) and a perfectly circular bokeh.
    • Analytic projections (fisheye/panoramic/orthographic, above) are likewise a cheap closed-form remap in the forward pinhole mode — a true wide field of view with none of the aberration or vignetting a real objective would add.
    • Physical (realistic) lens — lens { … }:
  • Materials:
    • diffuse - Lambertian reflector - reflect (spectrum or texture:<name>)
    • dielectric - Refractive glass with dispersion - ior (Sellmeier glass or constant)
    • mirror - Perfect specular reflector - reflect
    • halfmirror - beamsplitter - reflect
    • glossy - Rough microfacet reflector - reflect, roughness
    • thinfilm - Single-layer interference (iridescence) - ior, film_ior, film_thickness (nm), substrate_k
    • multilayer - N-layer Abelès transfer-matrix stack - ior, substrate_k, repeated layer <n> <k> <nm>
    • grating - Reflective diffraction grating - reflect, groove_spacing (nm), groove_dir, max_order
    • fluorescent - Stokes-shifted fluorescence - reflect, absorb, emit, yield
    • mix - Stochastic blend of materials - repeated layer <material> <weight>
    • layered - Physical coat over a weighted body: reflect off the coat with prob R, else enter and pick one body lobe (energy-consistent). - coat { reflectance fresnel|thinfilm|manual, ior, roughness[/roughness_map], film_ior, film_thickness[/film_thickness_map], specular } + repeated body layer <material> <weight>
    • translucency - frosted glass, colored glass
    • Presets: 5 metals (polished glossy lobe, override with roughness), 9 glasses (dispersive dialectric), 6 iridescent / structural colour (thin-film or multilayer stacks
  • Light shape primitives:
    • (default) area - Rectangular area light - origin, u, v, normal, spd
    • sphere - Spherical area light - center, radius, spd
    • cylinder - Cylindrical tube light - center, axis, length, radius, caps, spd
    • spot - Cone spotlight with penumbra - origin, dir, inner_angle, outer_angle, spd
    • collimated - Thin parallel pencil beam - origin, dir, spd
    • env - Environment / IBL light - file (lat-long HDR) or spd, rotate, intensity
  • Light envelopes:
    • Blackbody - 3 presets + specify a color temperature
    • LED - 2 presets + specify a color temperature
    • Fluorescent - 4 presets
    • Gas-discharge lamps - 4 presets
Voice Recorder
Android program to record voice
https://github.com/inhahe/VoiceRecorder
Made with Claude Opus 4.8
Java
Made because the two voice recorders I tried (one of which had a rating of 4.8) were unsatisfactory.
  • Multiple formats: WAV (lossless PCM), M4A (AAC), Opus (Ogg). (WMA is not supported — see known-issues.md.)
  • Per-recording overrides: the pre-record dialog lets you change the format, sample rate and (for compressed formats) the bitrate for just that recording, on top of the
  • Configurable defaults: set the default format, sample rate, bitrate, channel count (mono/ stereo) and filename pattern in Settings.
  • Custom folder navigator: browse the filesystem, drill in/out, create new folders, and pick where recordings go.
  • Editable filenames: each recording gets a timestamped default name, shown in an editable dialog before recording starts.
  • Storage capacity readout: the main screen and the pre-record dialog show approximately how many hours of audio will fit in the target folder at the current settings.
  • Live frequency analyzer: while recording, a small real-time spectrum meter (FFT-based bars) is shown on the home screen for every format, and hidden again when you stop.
  • Foreground service: recording runs in a microphone foreground service with an ongoing notification, so it survives screen-off / backgrounding.
Milkdrop2-plus
Winamp Milkdrop visualizations plugin for Foobar2000 - supports the default UI only as of now
https://github.com/inhahe/Milkdrop2-plus
Made with Claude Opus 4.6
C++
  • Uses DirectX 11.1 (Direct3D 11.1, DXGI 1.6, Direct2D 1.1, DirectWrite 1.1) for rendering.
  • Configurable through foobar2000 preferences instead of .ini files.
  • Can build 32-bit and 64-bit x86 component configurations as well as ARM64 and ARM64EC.
  • Recursive preset scanning - Automatically finds .milk files in nested subdirectory structures (e.g., the Cream of the Crop collection organized by category).
  • Category selector - Tri-state checkbox TreeView dialog for selecting which preset categories to include in shuffle. Selections persist across sessions.
  • Favorites system - Add/remove presets to favorites via right-click menu. Manage Favorites dialog with scrollable list, double-click to load, remove button.
  • Random preset from category - Right-click menu to load a random preset from a specific category.
  • Shuffle modes - All presets, selected categories only, favorites only, or favorites in selected categories.
  • Configurable preset library - Point the plugin at any directory containing .milk presets via right-click > Set Preset Library Folder.
  • Fullscreen hotkeys - In fullscreen mode, keyboard shortcuts are shown in the right-click menu (Space, Backspace, R, F11, Shift+F11, etc.).
Thumbsup fork
Fork of the Thumbsup web gallery
https://github.com/inhahe/Thumbsup
Made with Claude Opus
JavaScript, uses Node.js
  • AI indexing and searching of images, including OCR and natural language search, can use the GPU
  • Auto-detects when directories have been renamed or moved around so as not to reduplicate all the indexing effort for those files
  • Everything else Thumbsup already supports, such as image and video support for almost every format, nested directories and built-in, customizable templates
4djulia
3DJulia
Shows 2D planes or 3D hyperplanes of the 4D julia set
https://github.com/inhahe/3djulia
https://inhahe.com/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://inhahe.com/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://inhahe.com/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.
Spectral Bounce
Bouncing shapes and/or glyphs that bounce around the screen and cross over each other and subtract like filters or add like light sources according to actual spectral envelopes
https://github.com/inhahe/spectral-bounce
https://inhahe.com/spectral-bounce/
Made with Claude Opus 4.8
HTML/JS/CSS
  • Conigurable:
    • Use circles, squares, rectangles, and/or glyphs (cp437, letters+numbers+symbols, emojis, or full unicode)
    • Font (select an installed font or open a file)
    • Mean and range for bell curve distribution of shape speeds
    • Which filters/spectral envelopes appear on the screen
    • Background blackbody color temperature
    • Brightness of the shapes
grep
grep.py - cross-platform grep with an extra feature or two
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 Opus 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 Opus
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
  • Can expand edit commands to differential visual comparisons of both files similar to UltraCompare's.
  • MCP-capable
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
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
Audio Clip Editor
I tried using Audacity and REAPER and didn't find them intuitive to figure out, so I made my own.
https://github.com/inhahe/AudioClipEditor
Made with Claude Opus 4.8
C++, Windows
  • Cleanup voice
  • Normalize volume
  • Fine-grained audio selection span capabilities
  • Simple, intuitive workflow
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
qtpyrc
Cross-platform IRC client
https://github.com/inhahe/qtpyrc
Overall framework made by me, the rest filled in with Claude Opus
Python, uses PySide
  • 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
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.
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
3dface
Watches you in your webcam and renders your face in a metallic skin in real time. Doesn't convert the top part of your forehead.
https://github.com/inhahe/3dface
Made with Claude Opus
Python, uses
  • Can show a smooth face or a tesselated one.
DictionaryGraph
A full graph-based analysis of Webster's 1913 dictionary and WordNet
https://github.com/inhahe/dictionarygraph
Made with Claude Opus
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
https://inhahe.com/5d-voxel-rotator.html
Made with Claude Opus
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
6drotate
Loads a video (or animated GIF) and treats every pixel of every frame as a 6-dimensional point made from its 2 x-y coordinates, its time (frame) coordinate, and its 3 RGB values, then allows you to arbitarily rotate it in 6D
https://github.com/inhahe/6drotate
https://inhahe.com/6d-video-rotator.html
Made with Claude Opus
HTML/CSS/JS
  • Configurable:
    • RGB, HSV, HSL or Mono mode
    • Dot size
    • Zoom (can use scroll wheel or pinch to zoom)
    • Ratio of color depth to spatial extent
    • Ratio of time extent to spatial extent
    • Time slab thickness (how much time is shown at once)
    • Working resolution and frame count (picked in a load dialog with a live memory estimate, up to full native)
    • Magenta / Black / Clamp toggle for out-of-gamut pixels.
    • Rotation sliders for all 15 axes
    • Randomize rotation
    • Animate rotation randomly
    • Reset all
  • Time playback (play or scrub through the rotated volume, with adjustable speed)
  • 3D view orbit (tumble the rendered result without re-rotating the cloud)
  • WebGPU renderer with a CPU fallback
  • Export PNG
  • Export video (records one full time-sweep to MP4/WebM, no external libraries)
cdcheck
Checks an optical disc (or, if you prefer, any other drive), reading the contents of every file and collecting all file I/O errors, file permission errors, directory I/O errors and directory permission errors to report them at the end (as well as at the time of offense). Useful for verifying the integrity of a CD/DVD/Blu-Ray. Only listed here because when I submitted it to Useless Python many many years ago, somebody reported to me that they'd actually been using it at his job.
https://github.com/cdcheck
Made by me
Python
  • Reads entire contents of files
  • Skips over errors rather than choking on them
  • Prints errors at the time they happen
  • Prints list of accumulated errors at the end
  • Handles file I/O errors, file permission errors, directory I/O errors and directory permissions
mod257
Made after this DEVIANTART entry: https://www.deviantart.com/mccann/art/RSA-xor-153857; the author explains the formula `pixel[x,y] = (abs(x+y) xor abs(x-y))^7 mod 257`; he says he was inspired by RSA encryption. Took some time to get Claude to crack the exact algorithm since mccann's rendering relied on floating point imprecision.
https://github.com/inhahe/mod257
https://inhahe.com/mod257/
Made with Claude Opus 4.8
HTML/CSS/JS
  • Choose authentic mode (mccann's; looks cooler) or actually accurate rendition
  • Hotkeys
  • Zoom in/out
  • Pan up/down/left/right indefinitely by dragging or hitting arrow keys
  • Save PNG
  • Two color modes
  • Jump to literal coordinates
  • Hide or show information/hotkey overlays
Slate OS
A new capability-based OS with a Windows feel (work in progress)
https://github.com/inhahe/SlateOS
https://inhahe.com/roadmap-detailed.md
Made with Claude Opus
Rust, Python
  • Microkernel. Only the scheduler, memory manager, IPC, capability enforcement, and interrupt routing run in kernel space. Drivers run in userspace (with an optional SPARK-verified + IOMMU-sandboxed in-kernel fast path for the cases where the speedup matters).
  • 16 KiB pages throughout the memory subsystem (not 4 KiB).
  • Capability-based security. Every kernel object is accessed through unforgeable handles; no ambient authority.
  • Channel IPC (structured messages + capability transfer) as the primary IPC mechanism — not file descriptors, not Unix signals.
  • Specialized syscalls (Linux-style, many syscall numbers) with optional io_uring-style batched submission, and versioned syscall tables for ABI stability.
  • No Unix signals for process control — shutdown and similar events are IPC messages. Hardware exceptions surface as language-level exceptions (SEH-style), not signals.
  • Case-sensitive filesystem, / path separator, all bytes allowed except / and null. ext4 first (port battle-tested code rather than inventing a filesystem).
  • Committed memory by default, with lazy allocation opt-in (no silent overcommit).
  • YAML for configuration, JSON-lines for structured logs (no binary logs).
  • No AI features in the OS itself (except speech I/O), and no ads.
  • Linux binary compatibility. A Linux-compatible syscall ABI (baseline Linux 6.6, reported as 6.6.0-slateos) lets unmodified Linux executables run alongside native SlateOS programs, in the style of FreeBSD's Linuxulator — implementing advertised syscalls/flags for real rather than silently no-oping them.
Soundshop
Soundshop
A headless, Python-scriptable VST3 host and audio engine
https://github.com/inhahe/SoundShop
Made with Claude Opus
C++, Python, uses JUCE
Cross-platform (maybe?)
A C++/JUCE server does the real-time audio work while an external Python client library drives it over named pipes, so you write ordinary Python — no GUI — to load plugins, schedule notes, automate parameters, and render audio to WAV.
  • Headless VST3 host / audio engine: the C++/JUCE server handles plugin hosting, sample-accurate MIDI/parameter scheduling, and offline WAV rendering; an external Python client drives it.
  • Runs the audio engine as a separate process from your Python script, keeping Python's GIL and garbage collector off the real-time audio thread and letting the engine be driven entirely programmatically (tests, batch pipelines, notebooks, other tools).
  • Two named pipes: a commands pipe (Python → C++) where every command returns a status byte so failures raise in Python instead of desyncing the pipe, and a notifications pipe (C++ → Python) for events (parameter changed, MIDI input, playback stopped, audio file loaded, …) read on a background thread.
  • Plugin support: VST3 on all platforms, AU on macOS, LV2/LADSPA on Linux.
  • Scan/load plugins, wire audio between processors and to the graph output, schedule MIDI notes (note, velocity, start, duration, channel), automate parameters, and render offline to WAV.
  • High-level Python composition libraries layered on top of the low-level host:
    • music_theory - notes, scales/modes, key changes, transposition, note↔MIDI
    • signals - composable control-signal DSL: build DAGs of modulators (oscillators, math, smoothing, wavetables) that nest and cross-modulate to drive any plugin parameter, with its own cache
    • tempo - TempoMap with beat↔sample conversion, tempo modulation, and a SignalEngine
    • daw - DAW-style Project/Track/Processor graph model, audio clips/comping, and Song save/load
  • Default sample rate 44100 Hz, block size 64 samples.
NotepadRedo
NotepadRedo
Like Notepad but with a branching undo/redo history tree and an a more advanced search feature
https://github.com/inhahe/NotepadRedo
Made with Claude Opus
C# (WPF, .NET 8)
Instead of a linear undo stack that discards the future when you redo down a new path, NotepadRedo keeps every state you've ever visited as a node in a tree, so you can freely explore alternative edits and jump back to any earlier version on any branch at any time.
  • Branching history tree: every edit becomes a node in a visual side-pane tree; undoing then editing starts a new branch instead of discarding what you undid, and clicking any node jumps the document to that state.
  • Condensed by default: shows only branch points, tips, and your current position (collapsing straight runs of edits into one row) while keeping undo/redo fully granular; a "Show all edits" toggle reveals every edit as its own row.
  • Configurable undo grouping: chunk typing into history nodes per line (Enter), per paste, or per character, and/or after a configurable typing pause.
  • Persistent history (off by default): a file's entire branching history is saved to a sidecar under %LOCALAPPDATA% and restored next time you open it, as long as the on-disk contents still match; old sidecars pruned after 90 days.
  • Tabs: multiple documents per window; tear a tab off by dragging it out to a new window, reattach/reorder tabs between and within windows, middle-click to close.
  • Multiple windows & instances: cross-instance IPC over a named pipe; opening an already-open file focuses the existing tab; new files can open in a new tab or a separate process.
  • Search (Ctrl+F): literal matching (searches exactly what you type, spaces and quotes included), case-sensitivity and whole-word toggles, and a proximity mode that finds where all listed items occur within N characters/words/lines of each other; clicking a result jumps the caret to it.
  • Autosave, crash recovery & session restore: periodic background autosave, recovered work offered on next launch, and a configurable reopen-last-session's-files option (Ask me first / Always / Never).
  • External-change detection & diff/merge: watches open files for outside modifications and offers reload/keep/save-aside or a side-by-side merge viewer with character-level intra-line diff refinement; can also lock open files against outside changes.
  • Configurable close-button behavior: close (with save prompts and Save All), minimize to tray, or minimize to taskbar.
  • Font & formatting: live-previewing Font picker, Bold (Ctrl+B) / Italic (Ctrl+I) toggles, size submenu, shared persisted editor font; word wrap toggle.
  • Per-user .txt file association (no admin): registers itself as capable of opening .txt so it appears in Open with and Default apps without hijacking the association.
  • Command-line: open files, --new (blank start), and --quit-prompt / --quit-save / --quit signals used by the build/deploy script to close running instances safely.
KeyNote NF (fork/contributions)
KeyNote NF
A tabbed, tree-structured rich-text notebook (Windows) — my fork/contributions to the long-running KeyNote NF project
https://github.com/dpradov/keynote-nf
Made with Claude Opus 4
Delphi / Object Pascal (Delphi 12 Athens)
KeyNote NF is a mature multi-tab, hierarchical RTF notes application; these are a batch of reliability fixes and usability features I added on top of it — mostly around making rich-text/HTML paste trustworthy, letting notes link to each other, and giving the tray/taskbar/close/minimize behavior sane, explicit options.
  • Reliable rich-text paste: waits for the async clipboard RTF to stabilize before converting, and lays out the hidden conversion browser at a real size (1024x768) so wide content copies fully instead of being clipped.
  • Paste auto-heal: when a source app's RTF looks lossy compared to its own plain text (estimates the visible-text length of the RTF and falls back if it recovers under ~80% of the text), KeyNote silently prefers the HTML flavor of the clipboard instead, so you don't paste mangled/empty content.
  • "Paste as HTML (convert)": an explicit menu item that forces the clipboard's HTML to be converted to RTF and inserted, for the cases where you want to override whatever the source offered.
  • Copy node link / paste as hyperlink: "Copy node link" on the tree copies a reference to a note node (via a custom clipboard format) without altering the node; pasting it inserts a live KNT hyperlink to that node. Plain left-click on such a link navigates straight to the target; right-click still opens the URL-action dialog.
  • Find improvements: the Find box is seeded with the word under the caret (without selecting it), and Wrap-around defaults to on; plus a shortcut to find a node by name.
  • Explicit on-Escape action: a dropdown to choose what the Esc key does — Nothing, Minimize to taskbar, Minimize to tray, or Quit — instead of one hard-coded behavior.
  • Separated tray vs. taskbar minimize: "Minimize to system tray" and "Exit to system tray" ([X]) are honored independently, so minimizing goes where you told it to and only the close button hides to tray when you asked it to.
  • Non-destructive File > Open: the open dialog is shown first and the current file is only closed once you've actually chosen a new one — cancelling leaves your current file untouched.
  • Already-open handoff: if you try to open a file that's already open in another running KeyNote instance on the same machine, it just restores and foregrounds that instance's window instead of opening a second, read-only copy (resolved via the note file's .lck sidecar, which now records the owning window handle).
  • Paste indent cleanup: reducing paste indentation also halves the oversized bullet/number-to-text gap so pasted lists don't look doubly indented.
  • Export/robustness fixes: plain-text export no longer aborts when the clipboard can't supply a requested format (a recoverable DV_E_FORMATETC is treated as recoverable instead of fatal), and image embedding is gated to formats that actually render images.
  • Installer niceties: file associations open files with -ignSI, and code-signing is conditional so the setup script can build unsigned with /DSKIPSIGN.