How an innovative mathematical music generator won top honors with its interdisciplinary approach and technical excellence.
Table of Contents
When Mathematics Meets Musical Composition
In the competitive world of tech hackathons, innovative solutions that link theoretical computer science with practical applications are rare gems. The annual Pi Day Hackathon has become a celebrated event for such breakthroughs, bringing together developers who use mathematical principles to tackle complex tech challenges. This year’s winner, Pi-Loom, stood out as the top solution that impressed the judges, especially Machine Learning Engineer Vladislav Shakhray.
“What immediately struck me about Pi-Loom was its elegant fusion of mathematical principles with artistic expression,” noted Shakhray, who currently serves as Machine Learning Engineer Technical Lead at Snap Inc. “Many hackathon projects claim to be interdisciplinary, but few genuinely integrate distinct domains as seamlessly as this one while demonstrating exceptional technical implementation.”
The Technical Mind Behind the Evaluation
Before delving into Pi-Loom’s architecture, it’s worth understanding the technical lens through which this project was evaluated. Vladislav Shakhray brings an exceptional combination of academic rigor and industry experience to his role as hackathon judge, with expertise spanning computer vision, machine learning, and software engineering across multiple leading tech companies.
At Snap Inc., Shakhray spearheads cutting-edge R&D in Neural and Inverse Rendering, 3D, and Generative AI technologies. His professional trajectory includes pivotal roles at leading tech companies, including Google, where he made statistically significant improvements to YouTube’s video language recognition system, and Meta, where he contributed to enterprise collaboration tools.
“When evaluating hackathon projects, I draw on my experience working with state-of-the-art generative AI and neural rendering systems,” explains Shakhray. “These fields require a deep understanding of both theoretical foundations and practical implementation constraints—precisely the balance that distinguishes truly exceptional technical solutions.”
This combination of theoretical expertise and practical implementation experience provided Shakhray with a unique framework for evaluating submissions—particularly those focused on transforming abstract mathematical concepts into creative applications.
Pi-Loom: Technical Architecture and Implementation
Pi-Loom represents a brilliantly innovative approach to algorithmic music composition that leverages the mathematical constant π not merely as a symbolic reference but as the fundamental creative input driving its AI composition system. The project’s architecture comprises five primary components:
1. π-Based Composition Engine
At the core of Pi-Loom is a sophisticated system that converts π’s digits into musical notes based on configurable scales and keys:
function mapDigitToNote(digit, scale, rootNote) {
// Map a digit (0-9) to a note in the selected scale
const scaleIndex = digit % scale.length;
const note = rootNote + scale[scaleIndex];
// Return MIDI note number
return note;
}
function generateMelodyFromPi(piDigits, scale, rootNote, length) {
const melody = [];
// Convert the specified number of digits to notes
for (let i = 0; i < length; i++) {
if (i < piDigits.length) {
melody.push(mapDigitToNote(parseInt(piDigits[i]), scale, rootNote));
}
}
return melody;
}
“The implementation of their digit-to-note mapping demonstrates sophisticated understanding of both musical theory and mathematical properties,” Shakhray observed during his technical assessment. “They recognized that not all mapping approaches yield equally pleasing results, and their algorithm shows careful consideration of musical intervals and harmony.”
2. AI Pattern Recognition System
Pi-Loom incorporates advanced algorithms that detect and highlight patterns within π’s sequence:
function detectPatterns(sequence, minLength, maxLength) {
const patterns = {};
// Look for patterns of various lengths
for (let len = minLength; len <= maxLength; len++) {
// Sliding window approach to find repeating sequences
for (let i = 0; i <= sequence.length - len; i++) {
const pattern = sequence.slice(i, i + len);
// Count occurrences of this pattern
if (!patterns[pattern]) {
patterns[pattern] = {
sequence: pattern,
positions: [i],
length: len
};
} else {
patterns[pattern].positions.push(i);
}
}
}
// Filter patterns that appear more than once
return Object.values(patterns).filter(p => p.positions.length > 1);
}
“What impressed me most about their pattern detection algorithm was its efficiency and musical relevance,” Shakhray noted in his evaluation. “They didn’t simply identify repeating sequences; they weighted patterns based on musical significance—patterns that create rhythmic or melodic cohesion received higher prominence.”
3. Harmony Generation Framework
Building upon the main melody derived from π’s digits, Pi-Loom intelligently creates complementary harmonies:
function generateHarmony(melody, harmonicStyle) {
const harmony = [];
melody.forEach(note => {
let harmonicNotes = [];
switch(harmonicStyle) {
case 'triad':
// Add major or minor triad based on scale position
harmonicNotes = [note, note + 4, note + 7];
break;
case 'jazz':
// Extended harmonies for jazz style
harmonicNotes = [note, note + 4, note + 7, note + 11];
break;
case 'counterpoint':
// Generate counterpoint following music theory rules
harmonicNotes = [note, generateCounterpointNote(note, melody)];
break;
}
harmony.push(harmonicNotes);
});
return harmony;
}
“The harmony generation component demonstrates their deep understanding of music theory principles,” Shakhray remarked. “They implemented proper voice leading and harmonic progression rules that transform a simple sequence of notes into rich musical compositions with emotional depth.”
4. Interactive Data Visualization
Pi-Loom features dynamic visualization of note frequencies and detected patterns:
function createVisualization(piDigits, patterns) {
// Chart.js implementation for digit frequency visualization
const ctx = document.getElementById('digit-frequency').getContext('2d');
const digitFrequency = Array(10).fill(0);
piDigits.forEach(digit => {
digitFrequency[digit]++;
});
new Chart(ctx, {
type: 'bar',
data: {
labels: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
datasets: [{
label: 'Frequency in π digits',
data: digitFrequency,
backgroundColor: 'rgba(54, 162, 235, 0.5)'
}]
},
options: {
responsive: true,
// Additional chart configuration
}
});
// Pattern visualization using Canvas API
visualizePatterns(patterns);
}
“Their visualization approach transforms abstract numerical data into intuitive visual representations,” Shakhray observed. “This bridges the cognitive gap between mathematics and music, making both more accessible to users with varying backgrounds.”
5. Immersive 3D Experience
Finally, Pi-Loom delivers an immersive interactive 3D representation of π implemented with Three.js:
function initThreejsVisualization(piDigits) {
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(window.innerWidth, window.innerHeight);
document.getElementById('3d-container').appendChild(renderer.domElement);
// Create a spiral representation of π
const geometry = new THREE.BufferGeometry();
const vertices = [];
piDigits.forEach((digit, i) => {
const angle = i * 0.2;
const radius = 5 + i * 0.01;
const height = i * 0.05;
const x = radius * Math.cos(angle);
const y = height;
const z = radius * Math.sin(angle);
vertices.push(x, y, z);
});
geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
const material = new THREE.PointsMaterial({
size: 0.2,
color: 0x00ffff,
transparent: true,
opacity: 0.8
});
const points = new THREE.Points(geometry, material);
scene.add(points);
// Camera position and animation
camera.position.z = 15;
function animate() {
requestAnimationFrame(animate);
points.rotation.y += 0.002;
renderer.render(scene, camera);
}
animate();
}
“The 3D visualization demonstrates sophisticated implementation of modern web graphics techniques,” Shakhray noted. “Their use of Three.js creates an immersive entry point that draws users in with an intuitive spatial representation of this abstract mathematical constant.”
Technical Evaluation Methodology: A Machine Learning Engineer’s Perspective
Shakhray’s evaluation of the hackathon submissions was methodical and comprehensive, reflecting his background in machine learning and computer vision. He described a three-tier evaluation framework that guided his assessment:
1. Theoretical Foundations Assessment
“I began by examining the theoretical foundations of each project,” Shakhray explained. “With Pi-Loom, the approach to mapping mathematical sequences to musical structures demonstrates a sophisticated understanding of both domains. The way they implemented digit-to-note conversion shows they grasped the mathematical properties that make certain numerical sequences more aesthetically pleasing when translated to musical form—a surprisingly complex problem that touches on Fourier analysis and cognitive psychology.”
To assess theoretical soundness, Shakhray evaluated each project’s approach against established principles in relevant domains, looking for novel applications of fundamental concepts.
“Pi-Loom’s use of π’s mathematical properties to guide musical composition revealed genuine insight into the structures that underlie both mathematics and music. Their approach wasn’t simply decorative—it demonstrated understanding of how patterns in numerical sequences can translate to meaningful musical structures.”
2. Implementation Quality Evaluation
Drawing on his experience developing systems at scale across companies like Google, Meta, and Snap, Shakhray applied rigorous standards to implementation quality:
“Having worked on systems at scale across multiple companies, I’ve developed a keen eye for implementation quality,” emphasized Shakhray. “Pi-Loom’s architecture revealed careful consideration of modularity, error handling, and performance optimization. Their integration of Next.js, Web Audio API, and custom AI pattern recognition algorithms was executed with exceptional technical finesse.”
Shakhray noted that Pi-Loom’s codebase demonstrated professional-grade software engineering practices:
“Examining their commit history showed thoughtful refactoring and optimization, particularly in how they improved the Pi calculation and UI performance. The way they structured their code to handle real-time audio generation while simultaneously running pattern detection algorithms showed exceptional technical maturity.”
3. Real-World Applicability
Finally, Shakhray assessed each project’s practical value and user experience:
“A technically brilliant solution that doesn’t address an actual user need remains merely an academic exercise,” he observed. “Pi-Loom created something genuinely engaging and accessible. Their interactive 3D visualization creates an immersive entry point that draws users in, while the sophisticated audio generation capabilities deliver a genuinely enjoyable musical experience.”
The educational potential particularly impressed him:
“What differentiated Pi-Loom was its potential to transform how people engage with mathematical concepts. By translating abstract numerical sequences into sensory experiences, they’ve created a powerful tool for mathematics education that makes complex patterns accessible through sound and visualization.”
A Clear Winner Emerges: Why Pi-Loom Stood Apart
When all evaluation criteria were considered, Pi-Loom emerged as the clear winner. Shakhray identified several factors that distinguished it from other impressive submissions:
“First, the technical implementation was exceptional,” he noted. “The team demonstrated mastery across multiple domains—from digital signal processing for audio generation to advanced pattern recognition algorithms to modern web development practices.”
“Second, the project demonstrated genuine interdisciplinary innovation. It wasn’t just about applying existing techniques; they developed novel approaches specifically tailored to the unique challenge of transforming mathematical constants into musical compositions.”
“Finally, Pi-Loom showed remarkable completeness for a hackathon project. From the core digit-to-note mapping algorithm to the immersive 3D visualization, every component received careful attention and reflected professional-grade implementation.”
Future Implications and Development Potential
According to Shakhray, Pi-Loom represents just the beginning of what could become a significant advancement in both algorithmic composition and mathematical education.
“The approach demonstrated by Pi-Loom has broader implications for how we approach AI-driven creativity,” he explained. “Their roadmap for future enhancements—including more advanced musical scales, machine learning for sophisticated pattern recognition, and collaborative composition features—suggests a thoughtful vision for how this technology could evolve.”
From a technical perspective, Shakhray identified specific architectural enhancements that could further strengthen the project:
“Implementing more sophisticated machine learning techniques could enhance their pattern recognition capabilities, potentially uncovering deeper mathematical structures within π that have musical significance. Adding support for different mathematical constants would create interesting comparative studies. And developing a collaborative composition mode could transform this into a powerful educational platform.”
Bridging Mathematics and Music Through Technical Innovation
As our conversation with Vladislav Shakhray concluded, he reflected on why Pi-Loom represents an important advancement in computational creativity:
“What makes Pi-Loom special is how it reveals the hidden connections between seemingly disparate domains. The team recognized that abstract mathematical constants like π contain rich patterns that, when properly translated, can create aesthetically pleasing musical experiences. This insight opens new possibilities for both mathematical education and creative expression.”
The Pi-Loom team plans to continue development, with an open-source release scheduled for later this year. Their work exemplifies how hackathons can produce solutions that combine technical excellence with meaningful intellectual impact.
“The most promising aspect of Pi-Loom isn’t just what it does today, but how it might influence how we approach similar problems tomorrow,” Shakhray concludes. “Throughout my career across multiple technical domains, I’ve found that the most enduring solutions are those that recognize and exploit fundamental patterns rather than merely implementing incremental improvements to existing approaches. Pi-Loom exemplifies this principle—and ultimately, that’s what made it a worthy winner of this competition.”
For those interested in exploring Pi-Loom’s approach to mathematical music, the team has made a demonstration available online, allowing educators, musicians, and curious minds to experience how mathematical constants can transform into harmonious musical compositions.
Author’s note: This article is part of our ongoing series on technical excellence and project evaluation. All technical details referenced are from the official 2025 Pi Day Hackathon results.
