Boscop

Roli Piano: Synthesia Interaction with Real-time Octave Shifting and Scale Lighting

This script allows the ROLI PIANO to interact visually with the Synthesia software. It provides real-time visual feedback for MIDI input (optimized for Synthesia) while maintaining a persistent background scale guide with customizable roots and modes.

Key Features

7-Mode Scale Cycling: Toggle between No Scale, Major, Minor, Pentatonic (Maj/Min), and Blues (Maj/Min).
6-Mode Palette Cycling: Cycle through 6 color palettes.
Warm Root Identification: The root of the scale is highlighted in a warm Cream/Parchment tint, providing a clear visual anchor.
Dimmed Background Guide: Non-root scale notes are shown in a dim neutral grey (low intensity) to assist navigation without distracting from active MIDI notes.

Claude-SPARC Automated Development System For Claude Code

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

Overview

The SPARC Automated Development System (claude-sparc.sh) is a comprehensive, agentic workflow for automated software development using the SPARC methodology (Specification, Pseudocode, Architecture, Refinement, Completion). This system leverages Claude Code's built-in tools for parallel task orchestration, comprehensive research, and Test-Driven Development.

Features

Scaling HVM towards an Optimal Theorem Prover

Why an Optimal Theorem Prover implies AGI?

Theorem Proving is the ability to solve a mathematical problem. A computer program capable of competently doing that would immediatelly unlock the automation of every intellectual task that a human can perform, because all problems can be reduced to that of solving abstract equations. From the discovery of new physics, to recursive self-improvement and unfathomable

Note: This is an old post from back when I was trying to make sense of why inets are so fast for evaluating some λ-terms. It has some silly bits, I learned a lot since and could probably write a better article today, but I think this can still be insightful for these getting started, so I'll leave it here.

Yesterday, I reported the bizarre observation that certain functions can behave as if they had negative complexity. If you haven’t checked that article yet, it isn’t necessary, but you should, as it may blow your mind. In short, the λ-term f(bits) = copy(comp(inc,n,bits)), when given to optimal λ-calculus evaluator, is asymptotically faster than g(bits) = comp(inc,n,bits); i.e.,copy (a O(1) operation for a fixed size) behaves as if it had a O(1/n) complexity, causing the program to run faster by doing more things (!?).

That’s not the only bizarre complexity result I had when

Fast Discrete Program Search 2

I am investigating how to use Bend (a parallel language) to accelerate Symbolic AI; in special, Discrete Program Search. Basically, think of it as an alternative to LLMs, GPTs, NNs, that is also capable of generating code, but by entirely different means. This kind of approach was never scaled with mass compute before - it wasn't possible! - but Bend changes this. So, my idea was to do it, and see where it goes.

Now, while I was implementing some candidate algorithms on Bend, I realized that, rather than mass parallelism, I could use an entirely different mechanism to speed things up: SUP Nodes. Basically, it is a feature that Bend inherited from its underlying model ("Interaction Combinators") that, in simple terms, allows us to combine multiple functions into a single superposed one, and apply them all to an argument "at the same time". In short, it allows us to call N functions at a fraction of the expected cost. Or, in simple terms: why parallelize when we can share?

A

Higher-Order Company: Complete Historical Overview

This document is a complete historical overview of the Higher Order Company. If you want to learn anything about our background, a good way to do so is to feed this Gist into an AI (like Sonnet-3.5) and ask it any question!

My Search for a Perfect Language

It all started around 2015. I was an ambitious 21-year-old CS student who, somehow, had been programming for the last 10 years, and I had a clear goal:

I want to become the greatest programmer alive

	// LamBit.ts
	// =========
	// A minimal linear functional language with binary pattern matching.
	//
	// Func ::=
	// \| Mat ::= "λ" "{" "0" ":" Func ";" "1" ":" Func ";" "}"
	// \| Lam ::= "λ" Name "." Func
	// \| Ret ::= Term
	//
	// Term ::=

	// Post: https://x.com/VictorTaelin/status/1854326873590792276
	// Note: The atomics must be kept.
	// Note: This will segfault on non-Apple devices due to upfront mallocs.

	#include <stdint.h>
	#include <stdatomic.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <time.h>

	// HVM3 Core: single-thread, polarized, LAM/APP & DUP/SUP only
	// Based on: https://gist.github.com/VictorTaelin/2aba162f2b04478dc53e5615f482db7b

	#include <stdint.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stdatomic.h>
	#include <string.h>
	#include <time.h>

	import Control.Monad (forM_)
	import Data.Char (chr, ord)
	import Debug.Trace
	import Prelude hiding (LT, GT, EQ)
	import System.Environment (getArgs)
	import System.Exit (exitFailure)
	import Text.Parsec ((<\|>))
	import qualified Data.Map.Strict as M
	import qualified Text.Parsec as P