moonshotai

/

Kimi-K2.6

like 1.21k

Follow

Moonshot AI 9.58k

Next was a new melody, longer one, it wasnt without errors, in first attempt it was unplayable, but after one repair and rechecking the code - the success!
This test is quite hard for models, they are not just need to remember the rules of musical ChucK language, but also remember the original melody notes as second part and in third attempting to combine both to be playable in ChucK - the thinking data is almost 10 pages long and on my ANCIENT Xeon PC with 768Gb RAM only CPU takes usually whole night, but at night the electricity is 50% discount, stable highest quality 1 token/second.
Example #2, a long almost 3 minutes melody, aka Rondo alla Turca (K. 331, III), but its very different, so here test is kinda 50% failed, no exact recreation, but something very melodic, it also was able to calculate code to be 3 minutes long which is not easy for models (you can see in comments to every code line how it tries to calculate time of song), the start is slightly monotonic.
Behold the result (ChucK player supplied from Stanford University in https://chuck.stanford.edu/ide/):

// ============================================================
//  Mozart – Rondo alla Turca (K. 331, III)
//  ChucK solo piano (~2 min 55 s)
//  Structure: A A A A A A A A | B B B B | A A A A |
//             Turkish episode | A A A A | B B B B |
//             A A | Turkish episode | Coda
//  Fixed voice-pool call and UGen.gain assignment
// ============================================================

Rhodey p[12];
NRev rev => dac;
for (0 => int i; i < 12; i++) {
    p[i] => rev;
    0.22 => p[i].gain;            // FIX: gain is a property, not a method
}
0.09 => rev.mix;

// ---- timing (quarter = 132 BPM) ----------------------------
60::second / 132.0 => dur Q;      // quarter note (the beat)
Q / 2.0                        => dur E;   // eighth note
Q * 2.0                        => dur H;   // half note

// ---- voice pool ---------------------------------------------
int v;
0 => v;

// fire a note on a SPECIFIC pooled voice
fun void voiceOnIdx(int idx, int note, dur len, float vel) {
    if (note <= 0 || idx < 0 || idx >= 12) return;
    Std.mtof(note) => p[idx].freq;
    vel => p[idx].noteOn;
    len => now;
    0 => p[idx].noteOff;
    100::ms => now;               // release tail
}

// chord / poly helper
fun void chord(int notes[], dur len, float vel) {
    int grabbed[notes.cap()];
    // grab voices atomically
    for (0 => int i; i < notes.cap(); i++) {
        if (notes[i] > 0) {
            v => grabbed[i];
            (v + 1) % 12 => v;
        } else {
            -1 => grabbed[i];
        }
    }
    // fire all notes in parallel
    for (0 => int i; i < notes.cap(); i++) {
        if (grabbed[i] >= 0) {
            spork ~ voiceOnIdx(grabbed[i], notes[i], len, vel);
        }
    }
    len => now;
}

// rest helper
fun void rest(dur len) { len => now; }

// ============================================================
//  SECTION A  –  Octave theme (A minor, percussive)
//  8 eighths per call  (~3.636 s)
// ============================================================
fun void playA() {
    int n[3];

    // m1–2 | A B C A | E F# G# E |
    [81,69,45] @=> n; chord(n, E, 0.90);
    [83,71,45] @=> n; chord(n, E, 0.86);
    [84,72,45] @=> n; chord(n, E, 0.90);
    [81,69,45] @=> n; chord(n, E, 0.86);

    [76,64,40] @=> n; chord(n, E, 0.90);
    [78,66,40] @=> n; chord(n, E, 0.86);
    [80,68,40] @=> n; chord(n, E, 0.90);
    [76,64,40] @=> n; chord(n, E, 0.86);

    // m3–4 | A B C A | E D C B |
    [81,69,45] @=> n; chord(n, E, 0.90);
    [83,71,45] @=> n; chord(n, E, 0.86);
    [84,72,45] @=> n; chord(n, E, 0.90);
    [81,69,45] @=> n; chord(n, E, 0.86);

    [76,64,40] @=> n; chord(n, E, 0.90);
    [74,62,40] @=> n; chord(n, E, 0.86);
    [72,60,40] @=> n; chord(n, E, 0.90);
    [71,59,40] @=> n; chord(n, E, 0.86);
}

// ============================================================
//  SECTION B  –  Singing major-theme answer (A major)
//  16 quarters per call  (~7.273 s)
// ============================================================
fun void playB() {
    int n[3];

    // mm. 1–2
    [76,64,45] @=> n; chord(n, Q, 0.84);
    [73,61,45] @=> n; chord(n, Q, 0.80);
    [69,57,45] @=> n; chord(n, Q, 0.84);
    [71,59,45] @=> n; chord(n, Q, 0.80);

    // mm. 3–4
    [73,61,38] @=> n; chord(n, Q, 0.84);
    [74,62,38] @=> n; chord(n, Q, 0.80);
    [76,64,40] @=> n; chord(n, Q, 0.84);
    [73,61,40] @=> n; chord(n, Q, 0.80);

    // mm. 5–6
    [74,62,40] @=> n; chord(n, Q, 0.84);
    [71,59,40] @=> n; chord(n, Q, 0.80);
    [69,57,45] @=> n; chord(n, Q, 0.84);
    [68,56,45] @=> n; chord(n, Q, 0.80);

    // mm. 7–8
    [78,66,38] @=> n; chord(n, Q, 0.84);
    [74,62,38] @=> n; chord(n, Q, 0.80);
    [76,64,40] @=> n; chord(n, Q, 0.84);
    [76,64,40] @=> n; chord(n, Q, 0.80);

    // mm. 9–10  (sequential, higher)
    [69,57,45] @=> n; chord(n, Q, 0.84);
    [73,61,45] @=> n; chord(n, Q, 0.80);
    [76,64,45] @=> n; chord(n, Q, 0.84);
    [73,61,45] @=> n; chord(n, Q, 0.80);

    // mm. 11–12
    [78,66,38] @=> n; chord(n, Q, 0.84);
    [74,62,38] @=> n; chord(n, Q, 0.80);
    [76,64,40] @=> n; chord(n, Q, 0.84);
    [73,61,40] @=> n; chord(n, Q, 0.80);

    // mm. 13–14
    [74,62,40] @=> n; chord(n, Q, 0.84);
    [71,59,40] @=> n; chord(n, Q, 0.80);
    [73,61,45] @=> n; chord(n, Q, 0.84);
    [69,57,45] @=> n; chord(n, Q, 0.80);

    // mm. 15–16  cadence
    [71,59,40] @=> n; chord(n, Q, 0.84);
    [68,56,40] @=> n; chord(n, Q, 0.80);
    [69,57,45] @=> n; chord(n, Q, 0.88);
    [69,57,45] @=> n; chord(n, Q, 0.82);
}

// ============================================================
//  SECTION C / Turkish episode
// ============================================================
// low-register "drum" chords
fun void turkishMeasures(int count) {
    int am[4];
    int em[4];
    [69,64,60,45] @=> am;   // A minor + A2 bass
    [64,59,56,40] @=> em;   // E major + E2 bass
    for (0 => int i; i < count; i++) {
        if (i % 2 == 0) {
            chord(am, E, 1.00); chord(am, E, 0.98);
            chord(am, E, 1.00); chord(am, E, 0.98);
        } else {
            chord(em, E, 1.00); chord(em, E, 0.98);
            chord(em, E, 1.00); chord(em, E, 0.98);
        }
    }
}

// brighter, higher-register Turkish chords
fun void turkishHighMeasures(int count) {
    int am[4];
    int em[4];
    [81,76,72,45] @=> am;   // A5-E5-C5 + A2
    [76,71,68,40] @=> em;   // E5-B4-G#4 + E2
    for (0 => int i; i < count; i++) {
        if (i % 2 == 0) {
            chord(am, E, 1.00); chord(am, E, 0.98);
            chord(am, E, 1.00); chord(am, E, 0.98);
        } else {
            chord(em, E, 1.00); chord(em, E, 0.98);
            chord(em, E, 1.00); chord(em, E, 0.98);
        }
    }
}

// cascading descent flourish
fun void descent() {
    int n[1];

    [81] @=> n; chord(n, E, 0.96);   // A
    [80] @=> n; chord(n, E, 0.94);   // G#
    [79] @=> n; chord(n, E, 0.91);   // G
    [78] @=> n; chord(n, E, 0.89);   // F#
    [77] @=> n; chord(n, E, 0.86);   // F
    [76] @=> n; chord(n, E, 0.83);   // E
    [74] @=> n; chord(n, E, 0.81);   // D
    [72] @=> n; chord(n, E, 0.79);   // C
    [71] @=> n; chord(n, E, 0.77);   // B
    [69] @=> n; chord(n, E, 0.75);   // A
}

// ============================================================
//  CODA  –  decisive A-minor close
// ============================================================
fun void coda() {
    int n[3];
    [81,69,45] @=> n; chord(n, E, 0.94);
    [81,69,45] @=> n; chord(n, E, 0.92);
    [81,69,45] @=> n; chord(n, Q, 0.96);
    rest(E);
    // final chord held
    [81,69,45] @=> n; chord(n, H * 1.5, 1.0);
    rest(Q);
}

// ============================================================
//  MAIN  –  assemble the ~175 s arc
// ============================================================

// ---- Exposition --------------------------------------------
playA(); playA(); playA(); playA();   // ~14.5 s
playA(); playA(); playA(); playA();   // ~14.5 s  (total A x8)

playB(); playB(); playB(); playB();   // ~29.1 s

playA(); playA(); playA(); playA();   // ~14.5 s

// ---- Development / Turkish episode -------------------------
turkishMeasures(12);                  // ~10.9 s
turkishHighMeasures(12);              // ~10.9 s
descent();                            // ~2.3 s

// ---- Recapitulation ----------------------------------------
playA(); playA(); playA(); playA();   // ~14.5 s

playB(); playB(); playB(); playB();   // ~29.1 s

playA(); playA();                     // ~7.3 s

// ---- Final Turkish blaze -----------------------------------
turkishMeasures(12);                  // ~10.9 s
turkishHighMeasures(12);              // ~10.9 s
descent();                            // ~2.3 s

// ---- Coda --------------------------------------------------
coda();                               // ~3.2 s

// end

Everything above produced in fp16 cache quality. I've tried to save something in memory and uplift the speed with going down Q8 cache and in result it produced a working and even playing melody code, but musical harmony is gone completely, melody is horrible to even listen. I always said going lower quality is waste of time, there's no magic.