MayaFlux

Beyond Analog Metaphors

Click to expand

Most creative coding tools simulate analog hardware—virtual knobs, cables, circuit boards. This imposes constraints that don't exist in computation.

MayaFlux embraces true digital paradigms.

What Makes MayaFlux Different

Click to expand

Unified Data Streams

Audio, visual, and control signals are all numerical streams that can interact freely.

Digital-First Thinking

Recursive algorithms, grammar-defined operations, and non-analog logic are first-class citizens.

Live Coding with Lila

Modify C++ code at runtime via LLVM21 JIT—change algorithms without stopping audio.

Coroutine Temporal Control

C++20 coroutines treat time as compositional material, enabling sample-accurate scheduling.

Lock-Free Architecture

Atomic operations ensure real-time safety without locks or contention.

GPU Compute Integration

Vulkan compute shaders integrate directly into audio streams.

Philosophy

Click to expand

Data is Data

MayaFlux removes disciplinary boundaries—sound, visuals, control signals are all data.

Code as Creative Material

Data transformation is the creative act; programming is compositional structure.

Time as Structure

Temporal relationships are part of artistic expression, not implementation detail.

Hooks Everywhere

No protective abstractions; full access to computational machinery when you need it.

Built From Necessity

Click to expand

MayaFlux wasn’t built to improve on existing tools—it was built because they could not support the work already happening. It is the culmination of years of experience in performance, production, and education.

Built by the author with:

15+ years of interdisciplinary performance across Chennai, Delhi, and the Netherlands
Production audio engineering for Unreal Engine 5 and Metro: Awakening VR
Experimental creative computing education
Experience pushing the limits of instruments, Eurorack, and DSP systems

When tools protect you from complexity, they also protect you from possibility.

Current Status

Click to expand

Alpha: Core audio subsystem stable. Vulkan rendering in active development. Lila JIT working.

Production-ready: Audio processing, node graphs, memory management.

Validated: GPU compute routing, cross-modal connectors.

Future: Full 3D graphics stack, networking, OpenCV integration

Ready to Explore?

Click to expand

MayaFlux is for creators who've outgrown callback-driven thinking and want unified streams across audio, visual, and algorithmic composition.

Quick teaser

Click to expand



#pragma once
#define MAYASIMPLE
#include "MayaFlux/MayaFlux.hpp"

void settings() {
// Low-latency audio setup
auto& stream = MayaFlux::Config::get_global_stream_info();
stream.sample_rate = 48000;
}

void compose() {

    // 1. Create the bell
    auto bell = vega.ModalNetwork(
                    12,
                    220.0,
                    ModalNetwork::Spectrum::INHARMONIC)[0]
        | Audio;

    // 2. Create audio-driven logic
    auto source_sine = vega.Sine(0.2, 1.0f); // 0.2 Hz slow oscillator

    static double last_input = 0.0;
    auto logic = vega.Logic([](double input) {
        // Arhythmic: true when sine crosses zero AND going positive
        bool crossed_zero = (last_input < 0.0) && (input >= 0.0);
        last_input = input;
        return crossed_zero;
    });

    source_sine >> logic;

    // 3. When logic fires, excite the bell
    logic->on_change_to(true, [bell](auto& ctx) {
        if (ctx.value >= 0) {
            bell->excite(get_uniform_random(0.5f, 0.9f));
            bell->set_fundamental(get_uniform_random(220.0f, 1000.0f));
        }
    });

    // 4. Graphics (same as before)
    auto window = MayaFlux::create_window({ "Audio-Driven Bell", 1280, 720 });
    auto points = vega.PointCollectionNode(500) | Graphics;
    auto geom = vega.GeometryBuffer(points) | Graphics;

    geom->setup_rendering({ .target_window = window });
    window->show();

    // 5. Visualize: points grow when bell strikes (when logic fires)
    MayaFlux::schedule_metro(0.016, [points]() {
        static float angle = 0.0f;
        static float radius = 0.0f;

        if (last_input != 0) {
            angle += 0.5f; // Quick burst on strike
            radius += 0.002f;
        } else {
            angle += 0.01f; // Slow growth otherwise
            radius += 0.0001f;
        }

        if (radius > 1.0f) {
            radius = 0.0f;
            points->clear_points();
        }

        float x = std::cos(angle) * radius;
        float y = std::sin(angle) * radius * (16.0f / 9.0f);
        float brightness = 1.0f - (radius * 0.7f);

        points->add_point(Nodes::GpuSync::PointVertex {
            .position = glm::vec3(x, y, 0.0f),
            .color = glm::vec3(brightness, brightness * 0.8f, 1.0f),
            .size = 8.0f + radius * 4.0f });
    });