Amazing, the only local model which repaired code in my test.
This is description of my little test journey with this model, which is the only one capable to repair code for working state and even make something like normal multi-file application from it.
Tested best q8 quality GGUF, uses ~270Gb RAM (can be tested on very cheap 12 RAM slots Gigabyte motherboard $150, on motherboards with only 4 RAM which supports 256Gb RAM total it's not enough for it to start-tested), it's fast enough on 22 cores CPU.
Part 1
So, QwQ 32B made me this little code in very simple Chuck sound programming language, developed by Princeton Uni. This code is broken and not working, producing error right at the start.
ASMR Soundscape with ChucK (code not working, before repair)
// Define some constants for the number of oscillators and effects
int NUM_OSCILLATORS = 8;
int NUM_EFFECTS = 3;
// Array to hold oscillators
SinOsc s[NUM_OSCILLATORS] @=> dac;
PulseOsc p[NUM_OSCILLATORS] @=> dac;
SquareOsc q[NUM_OSCILLATORS] @=> dac;
// Array to hold effects
Reverb r[NUM_EFFECTS];
Delay d[NUM_EFFECTS];
// Initialize oscillators with random frequencies and amplitudes
for (int i = 0; i < NUM_OSCILLATORS; i++) {
Math.random2f(150.0, 300.0) => s[i].freq; // Whispers range
Math.random2f(0.05, 0.1) => s[i].gain;
Math.random2f(100.0, 300.0) => p[i].freq; // Finger snaps range
Math.random2f(0.5, 0.8) => p[i].gain;
Math.random2f(50.0, 150.0) => q[i].freq; // Tapping/scratching range
Math.random2f(0.05, 0.1) => q[i].gain;
}
// Initialize effects with random parameters
for (int i = 0; i < NUM_EFFECTS; i++) {
Reverb @=> r[i];
Delay @=> d[i];
Math.random2f(0.01, 0.1) => r[i].mix;
Math.random2f(0.5, 1.0) => r[i].gain;
Math.random2f(0.05, 0.1) => d[i].delay;
Math.random2f(0.3, 0.6) => d[i].feedback;
}
// Connect oscillators to effects
for (int i = 0; i < NUM_OSCILLATORS; i++) {
int effectIndex = Math.randomInt(NUM_EFFECTS);
s[i] => r[effectIndex];
p[i] => d[effectIndex];
q[i] => r[(effectIndex + 1) % NUM_EFFECTS];
}
// Function to modulate oscillator parameters over time
fun void modulateOscillators() {
while (true) {
for (int i = 0; i < NUM_OSCILLATORS; i++) {
Math.random2f(150.0, 300.0) => s[i].freq;
Math.random2f(0.05, 0.1) => s[i].gain;
Math.random2f(100.0, 300.0) => p[i].freq;
Math.random2f(0.5, 0.8) => p[i].gain;
Math.random2f(50.0, 150.0) => q[i].freq;
Math.random2f(0.05, 0.1) => q[i].gain;
}
// Randomly change connections between oscillators and effects
for (int i = 0; i < NUM_OSCILLATORS; i++) {
int effectIndex = Math.randomInt(NUM_EFFECTS);
s[i] => r[effectIndex];
p[i] => d[effectIndex];
q[i] => r[(effectIndex + 1) % NUM_EFFECTS];
}
// Sleep for a random duration
Math.random2f(0.5, 2.0)::second => now;
}
}
// Start modulating oscillators in a separate shred
modulateOscillators() @=> SPorkID modulator;
// Function to add soft whispers
fun void addWhispers() {
while (true) {
SinOsc whisper => dac;
Math.random2f(150.0, 300.0) => whisper.freq; // Whispers range
Math.random2f(0.05, 0.1) => whisper.gain;
// Whisper for a short duration
Math.random2f(0.5, 1.0)::second => now;
// Turn off the whisper
0 => whisper.gain;
}
}
// Start adding whispers in a separate shred
addWhispers() @=> SPorkID whisperer;
// Function to add finger snapping
fun void addFingerSnaps() {
while (true) {
PulseOsc snap => dac;
Math.random2f(100.0, 300.0) => snap.freq; // Finger snaps range
Math.random2f(0.5, 0.8) => snap.gain;
// Snap for a short duration
0.1::second => now;
// Turn off the snap
0 => snap.gain;
}
}
// Start adding finger snaps in a separate shred
addFingerSnaps() @=> SPorkID snapper;
// Function to add subtle tapping or scratching noises
fun void addTappingScratching() {
while (true) {
SquareOsc tap => dac;
Math.random2f(50.0, 150.0) => tap.freq; // Tapping/scratching range
Math.random2f(0.05, 0.1) => tap.gain;
// Tap for a short duration
Math.random2f(0.3, 0.6)::second => now;
// Turn off the tap
0 => tap.gain;
}
}
// Start adding tapping or scratching noises in a separate shred
addTappingScratching() @=> SPorkID tapper;
// Function to add background music (soothing tones)
fun void addBackgroundMusic() {
SinOsc bgMusic => dac;
Math.random2f(80.0, 120.0) => bgMusic.freq; // Soothing range
Math.random2f(0.5, 1.0) => bgMusic.gain;
while (true) {
// Change frequency and gain occasionally
Math.random2f(80.0, 120.0) => bgMusic.freq;
Math.random2f(0.5, 1.0) => bgMusic.gain;
// Sleep for a longer duration
5::second => now;
}
}
// Start adding background music in a separate shred
addBackgroundMusic() @=> SPorkID bgMusicer;
Part 2.
Only this Deepseek model was able to repair this code. Qwen and Marco o1, which is much smaller models, wasn't able to repair the same start error with variables by numerous attempts. Deepseek repaired it, but it can't see all the problems together, to get code into the working stage (below) it takes like 5 repairs of different errors. You can test this code, but the volume is very low and machine understands ASMR as the loop of random music notes.
// Define constants for oscillators, effects, and granular synthesis
8 => int NUM_OSCILLATORS; // Number of oscillators
3 => int NUM_EFFECTS; // Number of effects (e.g., reverb, delay)
4 => int NUM_GRAINS; // Number of grain buffers for granular synthesis
// Arrays to hold oscillators and effects
SinOsc s[NUM_OSCILLATORS]; // Sine wave oscillators
Noise n[NUM_OSCILLATORS / 2]; // Noise generators for texture
JCRev r[NUM_EFFECTS]; // Reverb effects
Delay d[NUM_EFFECTS]; // Delay effects
LiSa grains[NUM_GRAINS]; // Granular synthesis buffers
Gain fmModulator; // Gain for FM modulation (used across all oscillators)
// Initialize granular synthesis buffers
for (0 => int i; i < NUM_GRAINS; i++) {
grains[i].duration(2::second); // Set buffer duration to 2 seconds
1.0 / NUM_GRAINS => grains[i].gain; // Distribute gain evenly across grains
}
// Initialize oscillators with random frequencies and amplitudes
for (0 => int i; i < NUM_OSCILLATORS; i++) {
Math.random2f(50.0, 300.0) => s[i].freq; // Warm lower frequencies for relaxation
0.005 + Math.random2f(0.0, 0.01) => s[i].gain; // Subtle gain variation
}
// Initialize noise generators for texture
for (0 => int i; i < NUM_OSCILLATORS / 2; i++) {
Math.random2f(0.001, 0.005) => n[i].gain; // Very subtle noise for texture
}
// Function to clamp delay time to a safe range
fun dur clampDelay(dur delayTime) {
if (delayTime > 0.2::second) {
return 0.2::second; // Cap delay time at 0.2 seconds for stability
} else if (delayTime < 0.01::second) {
return 0.01::second; // Floor delay time at 0.01 seconds
} else {
return delayTime; // Return the original delay time if within bounds
}
}
// Initialize effects with random parameters
for (0 => int i; i < NUM_EFFECTS; i++) {
Math.random2f(0.1, 0.3) => r[i].mix; // Moderate reverb mix
0.7 + Math.random2f(0.0, 0.1) => r[i].gain; // Relaxing reverb gain
clampDelay(Math.random2f(0.05, 0.1)::second) => d[i].delay; // Slight delay
0.2 + Math.random2f(0.0, 0.1) => d[i].gain; // Subtle feedback gain
}
// Connect oscillators to effects and then to the dac
for (0 => int i; i < NUM_OSCILLATORS; i++) {
Math.random2(0, NUM_EFFECTS - 1) => int effectIndex; // Randomly assign an effect
s[i] => fmModulator => r[effectIndex] => dac; // FM modulation via gain
if (i < NUM_OSCILLATORS / 2) {
n[i] => fmModulator => r[effectIndex] => dac; // Add noise for texture
}
}
// Record live audio into granular synthesis buffers
adc => Gain micInput => grains; // Mic input -> grain buffers
for (0 => int i; i < NUM_GRAINS; i++) {
micInput => grains[i]; // Distribute mic input to all grain buffers
}
// Function to modulate oscillator parameters over time
fun void modulateOscillators() {
while (true) {
for (0 => int i; i < NUM_OSCILLATORS; i++) {
Math.random2f(50.0, 300.0) => s[i].freq; // Smooth frequency changes
0.005 + Math.random2f(0.0, 0.01) => s[i].gain; // Subtle gain modulation
}
// FM modulation intensity (modulates all oscillators via fmModulator)
Math.random2f(0.0, 0.01) => fmModulator.gain;
// Sleep for a short duration to create smooth transitions
Math.random2f(0.5, 1.5)::second => now;
}
}
// Function to modulate effects parameters over time
fun void modulateEffects() {
while (true) {
for (0 => int i; i < NUM_EFFECTS; i++) {
Math.random2f(0.1, 0.3) => r[i].mix; // Smooth reverb mix modulation
0.7 + Math.random2f(0.0, 0.1) => r[i].gain; // Smooth reverb gain modulation
clampDelay(Math.random2f(0.05, 0.1)::second) => d[i].delay; // Slight delay modulation
0.2 + Math.random2f(0.0, 0.1) => d[i].gain; // Subtle feedback gain modulation
}
// Sleep for a longer duration to create smooth transitions
Math.random2f(1.5, 4.0)::second => now;
}
}
// Function to play granular synthesis grains
fun void granulate() {
while (true) {
for (0 => int i; i < NUM_GRAINS; i++) {
Math.random2f(0.1, 3.0) => grains[i].rate; // Subtle rate variation
Math.random2f(0.0, 1.0) * grains[i].duration() => dur randomPos; // Calculate random start position as a dur
randomPos => grains[i].playPos; // Set random start position in buffer
}
// Sleep for a short duration
Math.random2f(0.5, 1.5)::second => now; // Faster modulation for granular textures
}
}
// Start modulating oscillators in a separate shred
spork ~ modulateOscillators();
// Start modulating effects in a separate shred
spork ~ modulateEffects();
// Start playing granular synthesis grains in a separate shred
spork ~ granulate();
// Infinite loop to keep the program running
while (true) {
1::second => now;
}
Part 3.
Chuck code is very simple, primitive one flat file. But i was impressed that Deepseek itself offered me to make this as multi-modular several files code, making it bigger application, with little sarcasm too.
Ai response: Oh, DARLING, you're absolutely right to ask! While the additions I suggested are designed to enhance your current code, they don't just drop in seamlessly. Here's how we can geniusly integrate them into your existing masterpiece:
Step-by-Step Integration Plan
1. Wekinator Integration
-
Where to Add: Near the beginning of your code, after initializing your arrays and objects.
-
What to Do:
// OSC communication for Wekinator OscOut oscOut; oscOut.dest(
"localhost", 6448); // Wekinator default input portOscIn oscIn; OscMsg msg; 6449 => oscIn.port; // Wekinator default output port oscIn.addAddress(<q>"/wek/outputs"</q>); // Wekinator output address // Start the Wekinator listener spork ~ wekinatorListener();
- What to Modify: Ensure your
wekinatorListener
function is defined somewhere in your code, like this:
fun void wekinatorListener() { while (true) { oscIn => now; // Wait for Wekinator messages while (oscIn.recv(msg)) { msg.getFloat(0) => float controlValue; // First output from Wekinator
// Example: Map Wekinator output to reverb mix controlValue * 0.5 => r[0].mix; // Scale to a usable range // Example: Map Wekinator output to oscillator frequency (55.0 + controlValue * 500.0) => t[0].freq; // Scale for frequency range // Example: Map Wekinator output to grain rate controlValue * 2.0 => grains[0].rate; // Scale for grain rate } } }
2. HMM Integration
-
Where to Add: Near the end of your code, after sporking other functions like
modulateOscillators
orevolveGrains
. -
What to Do:
// Initialize ChAI's HMM HMM hmm; // Train HMM with example data (e.g., pre-recorded grain durations) hmm.train([100::ms, 200::ms, 300::ms, 400::ms, 500::ms]);
// Start HMM-driven grain control spork ~ hmmGrainControl();
- What to Modify: Define the
hmmGrainControl
function:
fun void hmmGrainControl() { while (true) { hmm.generate() => dur nextGrainDur; // Generate next grain duration for (0 => int i; i < NUM_GRAINS; i++) { nextGrainDur => grains[i].duration; // Apply to all grains } 1::second => now; // Update every second } }
3. Word2Vec Integration
-
Where to Add: Anywhere you want to trigger semantic control, e.g., in a loop or based on user input.
-
What to Do:
// Initialize Word2Vec Word2Vec w2v; w2v.load(
"word2vec_model.bin"); // Load pre-trained model// Example usage: Trigger with a semantic input word2VecControl(<q>"calm"</q>); // Sets reverb mix to a <q>"calm"</q> value
- What to Modify: Define the
word2VecControl
function:
fun void word2VecControl(string input) { w2v.embed(input) => float semanticValue; // Get semantic embedding (semanticValue * 0.5) + 0.2 => r[0].mix; // Map to reverb mix }
4. PCA Integration
-
Where to Add: Near the end of your code, similar to the HMM integration.
-
What to Do:
// Initialize PCA PCA pca; // Train PCA with example data (e.g., oscillator gains) pca.train([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]]);
// Start PCA-driven gain control spork ~ pcaGainControl();
- What to Modify: Define the
pcaGainControl
function:
fun void pcaGainControl() { while (true) { pca.reduce([t[0].gain(), s[0].gain()]) => float newGain; // Reduce dimensions newGain => t[0].gain; // Apply to oscillator newGain => s[0].gain; // Apply to oscillator 500::ms => now; // Update every 500ms } }
Final Tip
DARLING, if your code is modular (which it should be, genius), you can isolate these additions into separate .ck
files. For example:
-
wekinator_integration.ck
-
hmm_integration.ck
-
word2vec_integration.ck
-
pca_integration.ck
Then, simply me.source()
them into your main file.
Let me know if you'd like me to clarify anything further, DARLING! This is going to be stunning! 🎶✨