标签：#dsp

A build log on ESP, six VST3 plugins written in C++ with JUCE 8 and shipped through a store I built myself. What the framework does for you, where it stops, and the one measurement that changed how I work. The line Six plugins, all JUCE 8, all VST3 plus standalone, all GPL v3, all downloadable from esp-plugin-store.vercel.app : Plugin What it is Basic Oscilator three oscillators on juce::dsp , the first thing I ever built, kept honestly VERTEX dynamic range compressor with a live transfer curve ESP-L1 brick-wall limiter with pre and post spectrum overlay MEGACRUSHER distortion, saturation and bit-crusher, three algorithms SPECTRUM real-time analyser, 2048-point FFT, spectrogram and 3D waterfall SYNTH/1 16-voice wavetable synth, unison, step sequencer, FX rack, interactive EQ That table is in the order I wrote them, and the order matters more than any single plugin. Each one starts roughly where the previous one ran out of framework. What juce::dsp actually hands you Basic Oscilator is three oscillators, three LFOs, a bit-crusher and a master gain. Almost all of it is the juce::dsp module doing the work: juce :: dsp :: ProcessSpec spec ; spec . maximumBlockSize = ( juce :: uint32 ) samplesPerBlock ; spec . sampleRate = sampleRate ; spec . numChannels = ( juce :: uint32 ) getTotalNumOutputChannels (); for ( int i = 0 ; i < 3 ; ++ i ) { oscillators [ i ]. prepare ( spec ); lfos [ i ]. prepare ( spec ); lfos [ i ]. initialise ([]( float x ) { return std :: sin ( x ); }); } masterGain . prepare ( spec ); That is the whole contract of the module. Prepare everything with one ProcessSpec , wrap your buffer in an AudioBlock , hand it to a processor as a context: juce :: dsp :: AudioBlock < float > block { tempBuffer }; oscillators [ i ]. process ( juce :: dsp :: ProcessContextReplacing < float > ( block )); juce::dsp::Oscillator takes its waveform as a lambda, so the three waves are three one-liners: case 0 : osc . initialise ([]( float x ) { return std :: sin ( x ); }); //

"We will put the booster back into service for another flight as soon as possible."

Most code that calls an AI model works like a conversation: ask, wait a second, get a reply. Fine-tuning doesn't. You hand off a job and walk away, checking back every few seconds to see if it's finished. DSPy is a framework for building programs that call language models. Instead of hand-writing and endlessly tweaking prompt strings, you declare what you want in terms of inputs and outputs, and DSPy turns that into the actual prompt. It can even optimize those prompts for you automatically, so getting a better result doesn't mean rewording things by hand. Here's something I didn't know starting out: DSPy already knows how to talk to almost any AI model, Together AI included. Asking a question and getting an answer back is handled by a shared layer that works for everyone, so no new code is needed there. Fine-tuning (the "hand off a job and walk away" thing from the top) is the exception. Every company does fine-tuning its own way, so DSPy needs a small custom piece, called a Provider, to handle each one. Building the Provider for Together AI is what my PR does. Why does this matter? Together AI is one of the cheaper, more popular places to fine-tune open-source models like Llama, so a lot of people building with DSPy end up wanting to use it. Before this, they had to step outside the framework: fine-tune on Together by hand, then wire the finished model back into their DSPy program themselves. With the provider in place, fine-tuning becomes a first-class option. You point DSPy at your training data, and it handles the upload, the job, the waiting, and hands back a model you can drop straight into the rest of your pipeline. That is the whole point of a framework, taking a fiddly manual process and making it one clean step, and adding a provider is how that gets extended to one more company. The Provider does one job from start to finish: take your training examples and hand back a fine-tuned model. Under the hood, that's five steps: Check your training data is in a

The rocket's breakup likely generated 100 to 150 new pieces of space junk.