Hello everyone, I'm no pro musician and no pro coder, but I made an attempt at creating a web app that records your microphone and creates a song from it.

Just record 30, 40 seconds or more of your voice and some random sounds — the algorithm will cut the sounds up and arrange them into rhythm. Pick a genre and generate.

The dream is to create a free app that does it well. Once it's done I'll make a plugin for FL Studio.

Here is the web app, ready to use:

https://marcellomassardo-collab.github.io/mc-parrot/

Here is the GitHub repo, with the APK available to download and full documentation:

https://github.com/marcellomassardo-collab/mc-parrot

Comments are very welcome!

It's free, but development is a bitch — consider donating if you like the project.

(This is not AI!

The app does not collect any of your data)

Examples and docs:

https://github.com/surikov/webaudiopluginexample

Problem

I've seen many good music apps for web. They look beautiful and work well. But they all have one problem. You can't integrate them into any music editor to create music.

Bandlab is one of the best online DAWs. Millions of musicians use it. But it doesn't have an API for custom plugins.

Unlike the web, things are completely different on the desktop. Every professional DAW supports a VST API for custom plugins. You can create a VST plugin from your music app and use it in any DAW.

Solution

I created my own online sequencer that supports custom plugins. Minium Studio is open source. Minium Studio is good enough for creating complex music. I'll soon add a payment system so developers can sell their plugins.

Unlike Bandlab, it works equally well on desktop and mobile phones.

Ready to use plugins

• 10-band equalizer
• Compressor
• Echo/Reverberation
• Percussion, which contains about a hundred drum sounds
• Chords, which contains about a thousand pianos, organs, guitars, violins, etc.
• Yamaha DX7 for emulating a famous synthesizer
• Roland TR-808 for emulating a well-known drum machine
• Import from MIDI, GuitarPro, MusicXML
• Export to MIDI
• MIDIRU archive, which contains thousands of MIDI sounds from 1990th to 2010th
• Publish to share songs via social media, messaging, email, etc.

Coming from a languages and linguistics background (no CS), I ended up building a chiptune synthesizer entirely in x86-64 assembly — no audio library, no DSP framework, everything computed sample by sample from first principles.

The core idea that started it: sound is just a list of numbers, one per moment, describing where a speaker sits.

Generate the right numbers and write them out.

From there it grew to polyphony, ADSR envelopes, FM synthesis with a hand-built sine table, and effects like delay, chorus, Schroeder reverb, flanger, phaser, and a supersaw — the interesting part was getting them right in fixed-point without an FPU.

The best part of building an instrument from the bottom: when an effect works, you hear exactly why, because there's nothing between the math and the speaker but you.

All public on my GitHub: https://github.com/whispem

Happy to talk synthesis or the assembly side.

I've been editing travel vlogs and keep manually trying to sync background music to cuts and pacing changes, which takes forever and then half the tracks I find online aren't cleared for commercial use so I'm basically starting over every time. What I want is an API that can take my uploaded video and generate a synced original soundtrack automatically, something that reads the emotional arc and timing of the footage without me feeding it a bunch of prompts. (The licensing thing is a dealbreaker for me, I need commercial rights baked in.) Anyone found an AI video to music generator with API

Access that handles this kind of sync and duration matching natively?

Windows XP inspired ear trainer for those who want to sharpen their ears. (python script)

https://github.com/hicxsuntxvioles/Ear-Trainer-2000

Aural Mirror [free download]

An instrument that turns a painting into sound.

It reads the picture as if it were a spectrogram and plays what it finds.

First run

1

Open the file

Double-click auralmirror.html. Chrome, Edge and Firefox all work. Nothing is installed and nothing is sent anywhere.

2

Drop in a painting

Drag an image onto the page, or press load image…, or paste with Ctrl + V.

3

Press RENDER

The sound is built in advance, not live. A short piece takes a few seconds. The bar shows how far it has got.

4

Press play

Use the button or the space bar. A line moves across the painting to show where you are.

The two windows

The first window is your painting.

Circles mark the events the machine found, and their colour tells you what kind of event it is.

The moving line is the reading head.

The second window is the proof: a picture of the sound that came out.

If the fidelity number is high, this window looks like your painting.

That is how you know the sound really follows the image.

Both are always in view, side by side with the controls.

Click anywhere on the painting and the piece jumps to that moment.

The four layers

Four different machines read the same painting at the same time. Each has a level slider.

Turn one up, turn the others down, and the same picture becomes a different piece of music.

Spectral

Treats the picture as a spectrogram and turns it back into sound.

This is the layer that makes the sound resemble the image.

Events

Looks for edges, brush strokes and directions,

then plays each one as a separate sound with its own attack and decay.

Additive

A bank of tuned oscillators, one per frequency band, following the ink as the head passes.

Tuned to the musical scale you choose.

Granular

Scatters thousands of tiny grains.

Their sound is built from the average colour range of your painting,

so each picture has its own grain.

The mixer

After a render, the four layers stay separate.

You can raise and lower them while the piece is playing — no need to render again.

Press solo under a layer to hear only that one, and all to bring them back.

Mic, room, preamp and volume are also live.

Move them and you hear the change at once.

Moving around

Click anywhere on the painting.

The piece jumps to that moment: click on the left side to go near the start,

on the right side to go near the end.

With a circular or spiral reading path,

the angle decides the moment, so clicking works there too.

Saving your piece

Press WAV. The file is rebuilt with the mixer levels you are using right now, so what you save is what you hear.

It goes to your downloads folder.

Four minutes of stereo sound is about 45 MB.

You can also save a preset of your settings.

Included in the download you'll find HTML Instruments, a Max for Live device that lets you open AURAL MIRROR directly inside Ableton Live. It requires Ableton 12 and Max 9.

example: https://youtu.be/O-u1EDVn0qE

This is the best thing I’ve made. Basically it is irregular rhythms that are stacked and looped so they fill a larger cycle perfectly. The individual parts can sound awkward on their own, but together they become coherent without relying on normal bar/beat repetition. If it doesn't make sense reading it then trust me, just generate and listen for a few cycles. It gets very interesting!

It’s based on vuza canon music theory. There’s a whole 'How it works' page for anyone interested.

Please randomly generate some order from chaos. There is no AI, and you can export as much MIDI as you like for free:
https://melidigenerator.com/perfect-chaos-beat-generator/

FYI I did use AI to vibecode the website. I don’t like AI-generated music (like 99% of people) but I’m not really interested in having that debate. If you’re against people using AI for coding also, just don’t use it. All the programming logic comes from real analysis and research on rhythmic canons and if you want to use it rest assured you are not using AI.

And - in answer to questions asked by some Redditor’s in the linked comment above, btw this is not a bot-built or AI agent-coded project. I spent a year building it alongside a fulltime job: because I wanted to have a free-to-use easy transcription tool for myself, and I thought others might appreciate it too. I

I started building DrumScript in June 2025. The first pypi release was in May 2026. Currently we are in Alpha and would welcome feedback. We will release v1.0.0 when we have tested it more. We are also working with music information retrieval experts to benchmark the classification. The deterministic model isn’t perfect but that’s why we are asking for help. And why we are not releasing DrumScript as v1.0.0+. Please add issues you find to GitHub so we can track!

Also: this is an open-source Python package. To non-coders it means it is completely free to use. If I was an AI agent Im pretty sure Id charge for it. It has been extensively tested to ensure security: but if you DO find any issues please add them to the Issues tab. Or email hello.drumscript@gmail.com. Please bear in mind it might take some time to reply as we are working on this alongside fulltime jobs.

We dont have time to respond to people on Reddit always but GitHub is monitored.

I've recently built a little tool that translates video into MIDI data, which I’ve been using to modulate my music in some semi random ways. Thought some people here might find it interesting too.

It converts color/visual information from video into MIDI CC data, opening up some experimental modulation possibilities for synths, effects, and generative setups and works 100% offline.

You can connect it to your DAW and sync/control it from there. There’s also a demo video in the help section showing the app in action with music modulation.

I’d love to hear your thoughts or experiences if you try it out. I’m also considering expanding it with:

* MIDI note generation
* JPG/image support in addition to video and math based modulation

You can try it here and hope you'll have fun :-)

https://cafedelcadence.github.io/

Here's an overly wet sample of the Anagram in action with Amalgam A2 brown sound captured. Details in the video description.

https://youtu.be/dKZvcZEDjgQ

I’ve been working on a MIDI generator that might help producers and musicians find a starting point for new ideas. It's 100% free and doesn't request any user details.

Choose an instrument, genre, mood and length, then adjust the rhythm, harmony, complexity, dynamics and humanisation. It generates one editable MIDI part rather than attempting a complete arrangement.

https://melidigenerator.com/

Unlimited exports, no account. I’d love some feedback on the results, controls or anything that feels awkward to use.

I’ve been building IFAH, an audio instrument around a slightly different idea from a synth or DAW: instead of composing a track, you compose an acoustic environment that can be saved, reopened and distributed as a state.
A lot of the interesting work has ended up being around reproducibility
live vs offline rendering, sample-rate/device dependence, randomness inside the audio graph, and what “the same state” actually means when it reaches another playback system.
Short demo:
https://www.youtube.com/watch?v=ZQEnnkVZ51s
You can also open the Player here:
https://ifahinstruments.com/player
Would especially love feedback from people working on audio engines/DSP about the architecture and the reproducibility problem.

I built Afterdark Studio as a dependency-free, local-first browser music engine and would value technical peer review from audio programmers.

Source: https://github.com/seemorecodez/afterdark-studio

The 0.8.0-rc.1 Limited Beta includes deterministic song patterns, dual-deck analysis and transitions, microphone capture, BS.1770-style loudness/true-peak metering, offline vocal processing, and a synthetic-acoustics engine. The room system uses polygon footprints, octave-band materials, air conditions, source/receiver positions, analytic modes/HRTF, coarse 2-D FDTD, and worker-built impulse responses. Live convolution and offline rendering share the same deterministic impulse synthesizer.

Current regression evidence is 111 passing tests plus a 646-control Edge UI audit. I am looking for code-level feedback on Web Audio scheduling, worker boundaries, DSP validity, deterministic rendering, memory/CPU behavior, and test gaps.

Known boundaries are explicit: it is not a wave-equation-grade room solver or professional DAW, perceptual vocal features remain experimental, and the regional drill experiment is isolated in a disabled plug-in after failing its creative gate. I am the maintainer and am asking for engineering critique, not stars or sales.

This community feels like exactly the right place for this: a synthesizer written entirely in x86-64 assembly, no audio or DSP library, computing every sample by hand.

The building blocks:

• four oscillators (square, saw, triangle, LFSR noise)
• polyphony via buffer summing, ADSR envelopes
• FM synthesis with a hand-built sine lookup table (Bhaskara I's approximation, since there's no math lib)
• effects: vibrato/tremolo/PWM driven by an LFO, a delay line (ring buffer + feedback), a one-pole low-pass, a state-variable filter with resonance swept by an LFO, ring modulation, and a bitcrusher

Everything's fixed-point.

Doing DSP this close to the metal really forces you to understand each algorithm — no library abstracting the math away.

I'd love feedback from people who work at this intersection.

Repo: github.com/whispem/asm.fm (write-up on the how and why: https://medium.com/@whispem/i-taught-my-cpu-to-sing-in-pure-assembly-47a1a46761ef 🎶)

I had Grok AI make me a recreation of the Pocket Audios HiChord Synth because i'm a broke teenager who can't afford a $200 Synth :( .

it includes a recording, looping and downloading feature, and all the different sounds and profiles like the HiChord.

I open the html file just in my browser with CTRL + O.

anyways, i hope someone who can find this useful!

I'm a high school student who is developing a free plugin!

A few weeks ago you probably saw that I posted about COGG v1/v1.1/v1.2, a free plugin I built that metalizes and industrializes any sound. Specifically, harmonic distortion, metal plate convolution reverb, and pitch layering are there all in one chain. Great for experimental music and mainstream alike.

I wanted to update you guys with version 1.3's release! It comes with the highly requested TONE knob, which changes the pitch of the Metal knob's metal convolution reverb-like sound! Additionally, version 1.3 introduces a LINUX VERSION!

Of course, it's still free, no account needed, VST3 + AU for Mac, VST3 for Windows, VST3 for Linux.

Download now for free: https://plasma-hype.itch.io/cogg

Trailer of V1.2 [the previous update]: https://www.youtube.com/watch?v=5q5EUMhUcaw

Thanks to everyone who tried v1.2, v1.1 and v1.0 and gave feedback, this update came directly from figuring out what people actually wanted to do with it. I personally have used COGG in almost all of my FL projects ever since I released it. Please give it a shot and let me know what you think of the presets and plugin as a whole for COGG v1.4!

Also, feel free to submit some PRESETS! I'll add them and credit you on the website!

GitHub repo: pytosc

sh $ pip install py2tosc

No dependencies. Python 3.10 or newer. Documentation

Why

TouchOSC layouts are drawn by hand in a GUI editor, which is the right tool right up until the work is repetitive. Laying out a fader per parameter for a plugin with fifty-four of them, numbering an eight-by-eight pad grid, renaming two hundred controls, restyling everything, or keeping a layout in step with a config file -- all of it is an afternoon of clicking, or a few lines of Python:

```python import py2tosc from py2tosc import ui

faders = [py2tosc.fader(name=f"ch{n}", messages=[ui.midi_cc(n - 1)]) for n in range(1, 9)]

doc = py2tosc.Document(root=ui.row( *faders, gap=4, pad=8, frame=(0, 0, 1024, 768), name="mixer", ))

ui.row records how the faders should be arranged but cannot size them,

since it runs before the frame above it exists. resolve walks the finished

tree and divides that frame among them -- nothing has coordinates until it does.

doc.resolve()

doc.save("mixer.tosc") ```

Note that py2tosc is a rewrite of tosclib by Alberto Valdez, whose work established the original mapping between the .tosc format and Python that this library is built on.