WREN release history

in version 2021.3.29.0

    2020-10-27 : [BUG] Fixed a bug in the sample and hold mechanism of the RandSigs module. Sample and hold would only work on the leftmost two outputs, it now operates correctly on all outputs.
  • 2020-11-19 : Added a linear decay mode to the EnvARRetrig module. By default it will start up in exponential decay mode, like it used to be.
  • 2020-11-22 : Added a range selector to the Envelope (follower) module to allow it to act like a very slow exponential slew rate limiting module.
  • 2020-11-22 : [BUG] Fixed an issue in the MidiClockIn module where BPM ClockGen could not be selected for the Mode parameter.
  • 2020-11-22 : [BUG] Fixed an issue with the ClockGen module where the external tempo (BPM) control could not work with a control signal > 1, which limited it's use to about 240 BPM.
  • MultiDiv - Multiple divider with multiplexer 2020-11-23 : Made a new MultiDiv module, it consists of eight individually settable divider sections with a common clock and two common outputs.

    The individual dividers all have their own output and on top of that there is a built in multiplexer selecting from the individual outputs and routing to the mix output. The multiplexer is controlled by a sel input signal and it's start and span can be set and modulated as well. The xfade input will fade over the set span starting at the selection start.

    Each multiplexer step has in individual step output which will be active when that step is active, as indicated by the associated light.

    The idea is to clock this module with a relatively fast clock (for example the x16 output of the ClockGen module) such that steady patterns can be programmed with an occasional drum roll. Using the xfade controls steps can be faded over to each other (instead of abrubptly being switched over).

    Added a value control for each step with a mix output for it, this behaves like a set of multiplexed values, or like a sequencer. The individual outputs are zero when the step is not selected and equal to the knob set value when the step is active.

    Moved the module from the logic to the seq1 tab, and changed it's color accordingly.

    Note: the xfade control does not make smooth transitions as output values will change value on a clock edge only.
  • 2020-11-24 : From now on I'll start to use the dark green and orange colors on outputs as well (it used to be used on inputs only to reflect logic inputs that switch at 0.5 instead of 0.0 units). For outputs it will mean that it is a logic output with a 0.0 to 1.0 range instead of the usual -1.0 to 1.0 range. Otputs with switchable ranges will not be affected and will still have the lighter green color. Orange for audio rate high logic, and dark green for control rate high logic signals.

    Now if only I could remember the exissting modules using a 0.0 - 1.0 logic output range … ah, the MultiCompare module on it's individual outputs (but not on it's bus outputs), and that seems to be the only one sofar.
  • 2020-11-27 : Sped up the filter for the MidiClockIn module by a factor of hundred or so, making rhe module perform a factor of around sixty better.
  • 2020-11-30 : [BUG] Fixed a bug on all the filterbank based modules. When the ModeLow (or ModeHigh) mode would be changed from lowpass to bandpass (or from highpass to bandpass) (or the other way around) the filter would not get re-initialized properly and would sound wrong. A workaroud was to change some other parameter (like the filter frequency) to get it working properly again, this is no longer needed.
  • 2020-12-02 : Added an inverted output to the scale quantizer module, it calculates the inverted note as ( 19 - Note - ReferenceNote) mod 12. Not sure if this is the right thing for general negative harmony, but for the scale of C major it seems to be okay.
  • MonoPoly - Mono to Poly mode switcher 2020-12-20 : Added a MonoPoly module, it can switch a signal from mono to poly mode under control of it's poly input.
  • MonoPolyMulti - Multiple mono to Poly mode switcher 2020-12-21 : Added a MonoPolyMulti module, it can switch a set of signals from mono to poly mode under control of it's poly input.
  • 2020-12-23 : Added a 'dead zone' control to the RandSigs module. When the absolute value of the calculated output value would be below the 'dead zone' value the actual output will be set to zero. The 'dead zone' can be set from zero to one, and it can be modulated.
  • 2020-12-24 : Changed sthe step count for the Chladni filter module's p paramaeter from 257 to 4097 to get finer control over the value. Changed the module version to 2 to be able to convert old patches to the new behaviour.
  • 2020-12-24 : Added a Fact/Cent selector on the Chladni filter, in Fact(or) mode it will behave as it always did (upping the frequency with a factor for the next filter channel). In Cent mode it will set the amount of cents between the filter channels.
  • FifthBank - Another filter bank module, in fifths 2020-12-25 : Added a FifthBankModule, in addition to the Tritone and Third ones, it implements perfect fifths from step to step (factor 1.5 (3:2)). Omitted the frequency values under the sliders.

    Removed frequency references for all filter bank modules, to make them one unit (15 pixels) less high.
  • 2020-12-30 : todo: add links to Wren videos.
  • 2021-01-10 : Removed the shortcut indicator for the memu popup for displays, it used to say ctrl+enter but the actual shortcuts are either enter (after it got activated by clicking on it) or ctrl+left_mouse_button. I've fixed the popup menu shortcut indicator to show enter instead of ctrl+enter.
  • 2021-01-14 : Added assignable output type for the Logic Not module.
  • 2021-01-14 : Added amplitide modulation to the Math Amplifier module.
  • 2021-01-18 : For the SeqRandom module I've changed the help text to indicate that the hange one and the change all inputs are not triggering but are sampled inputs instead. Also changed the input type for the Act(ive) input to be high logic instead of logic (switching at 0.5 instead of 0.0) and also changed the change inputs to be of a high logic type.

    Did the same to the SeqRandVal module, and also mad the Act(ive) inputs for some other sequencers to be of the high logic type, so they mostly behave all the same now for corresponding inputs.
  • 2021-02-15 : Added some help text for the SeqChord module.
  • AbsMultiplier - Multiplier for positive only signals 2021-02-23 : Added an AbsMultiplier module, this module rectifies it's input values (cutting off everything less than zero to zero) and then multiplies those signals.
  • AnalogAndOr - Analog AND and OR 2021-02-23 : Added an AnalogAndOr module, this module performs both the analog OR and the anlog AND functionality. Anolog OR outputs the maximum value of all of it's inputs (or -1 when nothing is connected to it's inputs). Analog AND outputs the minimum of all of it's inputs (or 1 when nothing is connected to it's inputs).
  • 2021-02-23 : Added range modulation inputs to the ProgDivider module for the steps, low count and high count selectors.
  • HighNot - A high logic not module 2021-02-28 : Added a HighNot logic module, it is the same as the Not module except that it treats it's inputs as high logic, meaning that the inputs switch at a 0.5 level instead of the 0.0 level for the logic Not module. There was no room on the HighGate - A high logic gate module Not module to add an input level type selector, and I did not want to make the module any larger, so opted for a new module type instead. Then did the same for duplicating the Logic gate module into a Logic HighGate module.
  • 2021-03-07 : Added a speed input to the KS module.
  • 2021-03-22 : [BUG] wakyct found me a bug in the SquareLFO. The internal Warp parameter which should be set at 0.5 is never initialized and so has a value of zero. This results in an occasional spike only coming out of the mdule. Fixed the issue for the next release, and meanwhile please use the plain LFO set to a square wave output.
  • Const8 - A set of eight constants 2021-03-23 : Added two new module types, const8 and const16. They both provide a set of a settable constant value with a modulation input and a mute control. In addition to that a sum output is being maintained which holds the unmuted sums of the fader values multiplied by their multiplier input.

    Multiplier inputs will be set to 1.0 when nothing is connected to them.

    The only difference between the two types is the number of provided channels, eight vs. sixteen, the image is showing the eight channel one.

    These are just plain mixers, of course, where unused inputs have an input value of 1.0.
  • 2021-03-22 : [BUG] wakyct found me a couple of bugs in the OSC implementation, I've fixed those now. Also changed the addressing for module parameters a bit, whereas addressing was /<synthname>/<module_name_without_@>/<moduleid_paramname> it now is /<synthname>/<module_name_without_@>/<paramname>

    For example when the synth is named wren and the module(id) is an svf named as @aap and the parameter to be controlled is the frequency, the addressing to be used was /wren/aap/svf_frequency, and it now is /wren/aap/frequency.

in version 2020.10.17.0

    2020-09-11 : Added cents modulation to a couple of oscillator modules (Osc, MultiOsc and MultiPhaseOsc), maybe nice to add a little drift to them when used in poly mode (with connecting an LFO in random walk mode or something).
  • 2020-09-15 : I've added a new range for the Tapper, MidiClockIn and RateConverterr modules, they are now able to control the new 1 minute delay time (DEL long 1:00, for controlling that range on the DelayPoly module). This may break existing patches in that the range after loading an old patch may not be what was set when the patch was saved. So you'll want to check your settings for these three module types.
  • 2020-09-17 : Changed the BPM detection for the MidiClockIn module to react a bit less nervously. This makes the output signals better suitable to control long delay loops. BPM values are now updated only when a sync occurs. Also made the indicated value for the BPM rate indicator to show the filtered value instead of the raw detected value. It behaves reasonable now for a drum loop of over half a minute, it was pretty glitchy for loops of such a length before.
  • 2020-09-17 : Fixed a bug in the FreqCount module, the channel selection was not working properly.
  • Timer - A timer 2020-09-17 : Added a new module type, a timer. This one just displays how long the the run input has been active. The mode can be set such that on every time the run input goes active timing will either continue from where it was (incr. mode) or it will be be reset to zero (once mode). It will display the run time as hours:minutes:seconds.milliseconds (and it will overflow and start at zero again if a day boundary is past).

    Added a couple of outputs to be able to do something with the measured time interval. Output d for fraction of the day, h for fraction of hour, m for fraction of minute and s for fraction of second, all make positive saw waves with a range [0.0, 1.0].
  • 2020-09-23 : Sped up the MovingAverage module, it was silly slow.
  • 2020-09-24 : Added Q modulation to the TritoneBank and ThirdBank modules.
  • 2020-09-27 : Added input type control to the StereoPan module, such that it works the same way as the (mono) Pan module.
  • 2020-09-30 : Added a counter display to the Divider module, to be able to see the current internal state of it. For slowly counting counters this is handy to get an idea about how long it will take before the output flips. In my current patch this will be hours … right 256 * 256 * 7 minutes, and although the triggering input is random, it is good to know about … ow … that's a bit over 318 days, damn, better shorten things a bit!
  • 2020-10-04 : I've change the way poly to mono signal conversion is treated. It used to calculate the sum and then divide by the polyphony. but this made patches to be too soft often. So I decided to divide by the square root of the polyphony instead. This will make the sum of signal paths having identical signals too loud, but also it will make that sum less too soft in cas the signals are uncorrelated. I might end up eventually by not dividing at all … even … you just can not do this right …

    Ok, bad idea as it gives issues with feedback loops, undid it, attenuation is back to what it was, and it will still be needed to have some end stage amplification (or compression) on polyphonic patches to get the levels right.
  • 2020-10-04 : I've made a MonoOverride option for modules to allow modules in a polyphonic patch to be forced to execute in mono mode. This will cause the module to listen to channel 1 only and also it will output on channel 1 only (but maybe the latter will be changed such that it will output on all channels … not sure here). the override to mono can be set from the module popup menu, monofied modules will show with a distinctive (currently white) border.

    modules with mono indicated Okay, changed it so that the ouput will be sent to all channels and not just to the first one.

    Also added a distinctive (currently yellow) border for modules that are intrinsically monophonic. These can still be set to mono mode BTW, in which case their will change in that they do not process an input sum over all polyphony channels, but instead will just use channel 1 on it's own (and their border will go (currently) white in that case.

    Updated the patch layout version to 12 for this while maintainng backwards compatibility.
  • 2020-10-05 : Added a light cross hatch on mono modules to better indicate their status, and removed the border while keeping the colors yellow and white … see image above … hmm, the color mixing for 'lighting up' the hatch could be improved upon, for now I've just changed yellow to lime green.

    That didn't work too well either for me, sooooo, instead I made both white but did a cross hatch for intrinsically mono and a diagonal cross hatch for overriden to mono modules. So, for isnstance, in the image above the Compressor is intrinsically mono, and the Limiter, Volume and AudioOut modules are explicitly monofied, and the two mixers are 'regular polyphonic' modules.

    I guess, as it makes no sense for Limiter, Volume and AudioOut to be poly afrter an intrinsically mono module (the Compressor), this could be automated. That will be for a later date tho, if at all.

    Not always it will be the case that an intrinsically monophonic module will be followed by mono paths only. For instance the regular Delay, or the Reverb module have modulation inputs which can result in polyphonic output behaviour … so automation will need some thought.

    Overall, I do like these changes. It used to be that some extra patching was needed to make parts of the patch mono (by using PolySelect modules here and there) which can now be done by monofication of modules. This both saves some cycles and I just don't want all parts of the patch to be poly all the time.

    When another voice than voice 1 is wanted for a mono section one could still insert a PolyShift module before a monofied section.

    Possible alternatives would have been to use the concept of 'poly cables' (as VCV uses them) or to use abstractions set to a different polyphony than the main patch (as an extension to the 'effects area' idea as used in the NM G2). But I guess I'll just keep what I currently have.
  • 2020-10-06 : Made the visual feedback on mono modules depend on the selected polyphony, it will not be shown for patches with polyphony set to 1. Also made it optional in the Settings Screen F3 to be turned off completely.
  • 2020-10-06 : Another way to look at it it is that an intrinsical mono module is a summing module, in that it sums it's mono input signals over all poly channels (but this may not be true for all of it's inputs, for instance the standard delay modules will sum the incoming audio, but each voice will still have it's own uniquely modulatable tap). Whereas a monofied module is a selecting module, it only processes signals from the first poly channel (and that holds for all of it's inputs).

    So a summing (intrinsically) mono module may still have a polyphonic output, depending on the control signals being polyphonic or not. A monofied module will always have a monofied output as it will only look at signals in the first poly channel (but it will still output into (but identical for) all poly channels of a receiving module).
  • 2020-10-07 : Fixed a bug in the MovingAverage module where filter size changes would make it behave badly (had to clear the filter state). And also the old–data pointer was one off, resulting in incorrect filtering and integrating behaviour. This bug was introduced by the speedup implemented before.
  • 2020-10-12 : Built a simple limiter into the Compressor module (as I always ended up adding one manually), it acts in the same way as the Limiter module, so it is not parameterized, but it can be turned on or off. Limiting, when active, acts upon the Side, L and R outputs (after compression and not in bypass mode, bypass mode always couples the inputs to the outputs directly).
  • 2020-10-14 : For some reason in the Settings Screen F3 the sample rate selector got mislabeled as 'midi delay', fixed this.
  • 2020-10-14 : Added a sample and hold input to the RandSigs module. When it is not connected it does nothing, when it is connected a low to high logic transition on it will copy the internal output state to the actual outputs, and otherwise it will hold the latest output value. This can be used to sync the change of the random values to some external event. When not connected the module behaves like it always did with continues output changes. [UNTESTED as of yet].
  • 2020-10-17 : Added manual BPM control to the MidiClickIn module. This serves two purposes, being a) to be able to set a BPM value manually in case a MIDI clock is not available and b) to remember the latest BPM value in a saved patch, such that when on patch load a MIDI clock is not availble the module will use the BPM value the patch was saved with.

    When an incoming MIDI clock is being detected this will override the manual setting. Currently for some reason when the external MIDI clock is active hovering the mouse over the manual control will act a bit weird, but so be it for now … ok, fixed that too.

    Manual BPM settings can not be fractional, detected BPM rates howver generally will be. A BPM rate saved with a patch will be rounded to the nearest possible manual rate.
  • 2020-10-17 : I've removed all the 'smart' latency control stuff from the MIDI note in modules, it was not working properly. The only way to get it working okay is to have low enough audio latency (small enough audio buffers), all the fancying up is just crap. So anyway, a note is turned on and off like as quickly as possible now.

in version 2020.9.9.0

    2020-07-27 : Changed the internal representation of MIDI time to fractional seconds (instead of milli seconds) to have it the same as the synth timing. (Preparing for full MIDI event enqueuement, to be able to get the note-on and CC timing solid too, might also help to get clock sync better …).

    After some experimention I ended up not using an RX queue for now, to make it work properly it would be needed to also implement extra audio latency. The queue would be used to eliminate jitter on received MIDI, but when it is at the cost of added latency it is maybe better to accept some jitter and instead minimize that by selecting short audio queues (an audio queue of 512 frames at 48ks/s makes for a jitter of around 11 ms).
  • 2020-07-30 : The MIDI optimizations broke the handling of RPN data, as this was done by the MidiReceiver object (of class TMidiReceiver) which is no longer used. RpnMode is obeyed by the TX modules only now. Also MIDI RX logging is broken now, TX logging should still work.
  • 2020-07-30 : Started preparing for polyphony, upped the patch version to 11 and made the underlying system ready for propagating value sets over wires (instead of single values). The patch editor has a polyphony count, and so does the synhesizer module, now all the modules will need some work … and there will have to be some polyphony specific modules too.
  • 2020-08-03 : Made a good lot of the modules poly aware, skipping the hard ones a bit though. Now optimizing things a bit as the performance in mono mode is a bit disappointing sofar. Not unhappy though about the poly performance, going from mono to duophony does not double the CPU load, it just increases a bit. Well a bit more than a bit actually, but nothing like doubling.

    Implemented a couple of poly specific modules: PolySplit, PolyMerge, PolySum, PolySelect, PolyShift and PolyStatus – all doing some voice magic. The splitter takes off the voices from the poly bus routing them to individual outs, the merger does the reverse thing, bundling up individual inputs into voices. The PolySelect can select a voice from a bundle and output that on it's output. The PolyShift shifts voice positions in the bundle, voice one can be routed to voice two, and then two will go to three, and in a cyclic manner the highest voice number present is routed to voice one then, the amount of shift steps can be set with a knob. The PolyStatus just outputs the voice number on it's output, scaled from zero to one over the current polyphony, this can be used, for instance, to control a multiplexer which will then do some voice specific selection. Or control the wave shape of a shape modulatable oscillator, so voice one can be a sine, voice two a triangle, etc.

    But it is still a bit crashy at times, and for mono mode the overhead is quite large. The crashyness is related to the recorder module maybe, didn't really check it out, but didn's see it as of yet in patches not having a recorder module in it. Also didn't figure out the 'level issue' yet, a duophonic patch potentially is twice as loud an the mono version of it, but when the voices are independent it will, or can, be at almost the same level. Will probaly be left as an excercise for the user … to get the levels right, or maybe some square root based compensation magic on the final mix, or in all places where a voice mix is being made (like in reverb modules, but that's all a bit arbitrary still).

    I've hard limited the maximum voice count to 16.
  • PolySplit - A polyphonic voice splitter 2020-08-04 : Some notes about the implementation of polyphony. Most modules are completely polyphonic, some are monphonic and some are mixed mode modules.

    Fully polyphonic modules are either stateless (that is no memory of a previous sample set is being kept) or they have a separate internal state per voice. An PolyMerge - A polyphonic voice merger example of a stateless module is a mixer, mixers can be computed on a sample by sample base, they implement just a couple of multiplications and additions. A filter would be an example of a module having state, as the computation of the current sample depends on what samples it saw before. A fully polyphonic filter will keep that information on a per voice base, each voice has it's own memory.

    Monophonic modules are pretty simple too, if they have state it will be shared over all voices. An example of this is the Vocoder module. Monpphonic modules generally will, on their inputs, sum the incoming voices, then they proces that PolySum - A polyphonic voice summer sum as a single signal. Then the results will be distributed over all output voices equally. For clock inputs, for instance, this scheme makes no sense though, in such cases only the input from the first voice will be processed, the output will still be distributed over all voices. Note that polyphonic clocked modules, in contrast, treat the clock separately for each voice, so they will alwyas listen to all voices. Some examples of mono modules are the reverbs, not only would it be expensive, CPU wise, to make them fully polyphonic, it does not seem to make much sense either to have polyphonic reverb. Some more effects will be kept monophonic, like the compressor, where others, like pitch shifters, would be nice in poly mode.

    Then the mixed mode ones, these will have some shared state over the voices. For example the delay based modules may have a monophonic input, that is they listen PolySelect - A polyphonic voice selector to the sum of all voices. They wil then store that sum in a shared delay line, but the outputs can be polyphonic. each voice can have it's own delay modulation. Especially for the very long delays (like five minutes) it would be costly to have a delay line for each voice. I am considering some new fully polyphonic delays, but they will have short–ish delay lines, a couple of seconds, then, not minutes.

    PolyShift - A polyphonic voice shifter At times I have been too lazy to figure out the per voice state for modules, such modules may become polyphonic at some later stage. The MIDI modules for instance need work, their current implementation makes sense in a mono world only.

    I will label mixed mode modules as being polyphonic, for instance the Input module is labeled as poly, but there is no such thing as polyphonic input from a sound card. There are channels though, and those can be routed to separate voices if needed (by using some PolyMerge modules). The output module is mixed mode too, it will sum it's input voices before sending them to the sound card. The Recorder module behaves just like the Output module. The delay modules are labeled as poly as well, as explained in the mixed mode section above.

    All the 'simple' modules have been decided and implemented now as either poly or mono. There are still about 100 module types (of roughly 300) I still need to pay PolyStatus - A polyphonic status thingie attention to. Not only for the mono/poly issue, but poly modules need things to be reorganized a bit as well for optimization reasons, and I started with a non optimized rough version.

    Still, as long as I do not have a recorder module in the patch things seem stable sofar. Also patches with polyphony set to one need a bit more CPU time than in the monophonic program versions before, but I am pretty happy with the poly performance sofar.

    As there is more computation involved per module in poly mode, it may be needed to accept more audio latency, but will have to optimize better to be sure.

    Anyways, a couple of days more work will go into it easily.
  • 2020-08-07 : About 40 module type more polyphonized, still 60 or so undecided ones. Some are a real bitch to have them un-monoed … especially the filter banks took me lot of hours, but all filters are fully polyphonic now, including the voice like vowel filters. Next thing probably should be to change the MIDI modules, or come up with some new ones maybe, poly specific ones.
  • 2020-08-07 : I seem to have fixed the recorder bug, it probably was a bit crashy in the Wren release version too.
  • PolyMidiNoteIn - Polyphonic MIDI input module 2020-08-07 : Decided to add a polyphonic MIDI note in module and leave the old MIDI note in modules as as is (for compatibility with previous mono patches). The new module will set the 'max notes' value (as the Midi8NoteIn module has it) to be equal to the selected patch polyphony. Otherwise it should work exactly the same as the Midi8NoteIn module. With this module a patch can be made as if it were mono, and by upping the polyphony it will give more voices. For mono patches this may need a bit more CPU than in previous Wren versions, but with upped polyphony it will pay off.
  • 2020-08-07 : Polyfied MidiClockIn, Tapper and RateConverter modules. So there now is fully modulatable polyphonic MIDI and Tapper sync. Still 55 module types to consider, some will stay mono.
  • 2020-08-08 : I guess Wren now is a polyphonic multitimbral inter-voice cross-modulating virtual analog modular synthesizer … or something.
  • 2020-08-08 : All modules have had a look at, the following ones were kept monophonic for various reasons :
    AMuse, CellAut, CellAut2, ClockGen, ClockedDelay, ClockedSieve, Compressor, Convoder, Economy, eSpeakVoice, FlangeChorus, GVerb, GenePlayer, GrainDelay, Granulator, LifeSeq, Markov, Midi8NoteIn, MidiCCIn, MidiMultiNoteIn, MidiNoteIn, MidiPCOut MidiPNOut, MidiPlayer, MidiSysexOut, PitchChange, Reverb, RndGranulator, SeqPattern, SeqValues, Sieve, SimpleGranulator, SmallLifeSeq, Smear, Song, SwanSong, Talkie, TextWriter, VitaPHoBium, and Vocoder.

    Most mono modules will listen on the first voice only and will output equally over all voices. Some modules however will mix the incoming voices before processing, especially so for the FX modules. This may still need some fine‐tuning.
  • 2020-08-08 : So now the question is … is it any good … am I going to keep this?

    Anyway, doing some test runs now on mostl large old patches, finding some bugs here and there, and fixing those, but most stuff seems to still be runnable on a poly setting of 1, will test some more …
  • 2020-08-08 : I've changed the divtrig parmameter for the Seq16 and the Seq16Rep modules to have a maximum of 1024 instead of 255, this will cause some patch incompatibilities with previous versions (where the divtrig output was used).
  • DelayPoly - A polyphonic delay module 2020-09-02 : Added a new DelayPoly module which is fully polyphonic but it does not support delay times up to five minutes, only the short and medium ranges. So the time can be set from 100µs to 3s.

    Extended the maximum delay time to be 1 minute with a new long3 range, as I had some patches with delays in that range and wanted those delays to be polyphonic too. The rationale for not supporting 5 minutes is that such can eat up a lot of memory in poly mode (as the maximum length for the range will be allocated to allow for modulation over the full range).
  • PolySelectMulti - Multiple poly voice selector 2020-09-03 : Added a multi channel polyphonic voice slector, and also fixed a bug in the single channel version of it (the PolySelect module, just actually used the module for the first time – it had some shortcomings).
  • 2020-09-03 : I've upped the process priority for Wren to ABOVE_NORMAL_PRIORITY_CLASS, or at least made code to do so, a warning will be issued in the logs when setting the priority failed. The (relative) thread priority for the audio thread was alread set to THREAD_PRIORITY_TIME_CRITICAL, PortAudio apparently does that. Anyway, it's meant to to have it run a bit more smoothly, seems to be a marginal improvement at best.

in version 2020.7.27.0

    2020-07-27 : Fixes for MIDI modules. MIDI was not really dropping notes, but note-offs could follow immediately after note-ons, so a trigger out did not get generated. Changed the timing, such that the actual note duration is being tracked now. Another issue was that the MIDI modules were not fast enough, so changed their processing to be at audio rates. The third issue was that the low level MIDI code was posting messages to the GUI thread to signal incoming data. This was changed to let the MIDI driver inject MIDI messages directly into audio thread. This also greatly reduced the sensitivity to GUI events happening.

    Ran some tests on this and on my laptop with an ASIO buffer size of 256 the MIDI modules can now handle 1/16 notes at rates of 240 BPM. Audio buffer size matters still for MIDI timing accuracy, as a note-on event is not synced with the audio thread, only the duration is being calculated in samples now – so there still is note onset jitter, but that's a couple of milli seconds at most with the settings mentioned before.

in version 2020.7.23.0

    2020-07-23 : Some issues still with ins and params being mislabeled in places. Fixed the diagnostics for it and fixed the issues with it.
  • 2020-07-23 : Midi is supposed to be dropping notes. I've changed the handling for note-on and -off messages a bit. Also removed the direct control of the mide rx LED, just setting a flag for it and let the GUI task pick that up and turn the LED on. Also removed some memory allocation operations from the MIDI thread by setting a fixed size buffer. which gets then direcrly passed to the synth. The still is a small issue with this as the synth processes the MIDI in the audio thread, which works block wise, meaning that only avery buffer-size-samples the MIDI get to actually be processed. This is jittery with a frame size of 2048 samples, with 256 it is better. Not quite seeing how I could decouple this though.

in version 2020.7.20.0

    2020-07-20 : Made some unit testing code for param and in/out pin validation, found several hundreds of issues and amongst those were hidden a handful of bugs which may have resulted in the program to crash under certain conditions.

    I've fixed the bugs, the other issues were all due to irrelevant typos, lazy module naming, strange param names for multi valued controls (xypad and spiral), something with internal values being stored as parameters and how module inheritancce is being used. Anyways, all such issues were manually checked to be ok, and code was written to not show those anymore when the test is being run.

in version 2020.7.18.0

    2020-06-25 : Added some x64 specific optimizations; Turned on DAZ and FTZ flags to treat all denormals as zero and reduced the denormal correction functions to be Nops. Furthermore the check for denormals functionality built into the program will never see any for the 64 bit version. This seems to approximately give an extra 20% speed gain (as in 36% -> 30%) for the x64 version.
  • 2020-06-28 : I've made audio caching, such that a used audio file in wave player like modules will be loaded into memory only once. When the same audio is being used in another wave player like module the data will be shared. When the data is no longer used in the patch it will be deleted.

    This speeds up patching too when long waves are being used (as on a structural patch change (wires / modules / added / removed) all resources would be created anew, so audio would have to be reread from memory. In the current situation such data will be kept till after recompilation completed and only then, when the data turns out to be no longer needed, it will be released).
  • 2020-06-28 : Moved the 06-25 optimizations to a wider scope, it encompasses all real-time audio processing now (inccluding the bits for the level meters). It is not however used for offline audio processing, i.e. recording – planning to substantially change the recording mechanism anyway … but for now recording may still give exceptions on subnormals, infinities and NaNs.

    Note: As of 2020-07-02 the old non-real-time recording mechanism was removed, this leaves the debug wave plotting as the one non-real-time mode left, and as I'll probably keep that for a while it should be 64 bit optimized too (as is it can generate invalid floating point results or exceptions now).

    Note as of 2020-07-03 the above got fixed. Graphing is sillily slow though.
  • Recorder - A wave recorder module 2020-07-01 : Made a recorder module. I'ts tape length can be set from 1 to 30 minutes in one minute increments. When the tape is full it will loop, recording over the oldest material. There is a clear button to erase the tape and a write button to write out the tape to a disk file (a WAV file). The number of tape tracks can be set from 1 to 8 (WAV files can have up to 65536 channels). Recording can be start or stopped with the 'active' control. A file to write to must be selected before starting a writeout, or nothing will happen.

    The record output goes active when recording is stoped, connecting it to the clear and write inputs will cause the wave to be written to disk and to then be cleared. The full output goes active when the loop is 100% full, connected to the clear and write outputs will cause a recording to be saved each time the loop gets full.

    The eight audio outputs will output the input signal with a delay time set by the delay controls and the delay modulation input, as if it were a tape montoring signal.

    So … basically it is some sort of a primitive 8 track recorder with a looped tape.

    Made it use date and time prepended to the filename on save, such that when auto save is patched in a new file will be generated without overwriting old ones every time the tape gets full. Auto naming is optional trough the timestamped / normal selector, but it's on by default.

    Made auto normalization to be a user option as well, as when multiple takes are made automatic volume normalization would possibly lead to level inconsitencies between the various tracks. With normalization off they should be gluable in a wave editor.

    Changed the delay setup a bit. There now is a pre delay which can be set all the way from zero to 30 minutes and then there is delay modulation added to that. The modulation can be set from 100µs to 30ms for its maximum length and it can be modulated in a range -1 to 1 times the set value.

    Note: recording 30 minutes with 8 channels @ 96 kbps will fail as the maximum RIFF chunk size of 4 GiB would be exceeded. Some limits will have to be put in to make sure that a valid wave will always be written. And then again. maybe a limit of 2 GiB should be used to avoid problems with software implementing the size fields as signed 32 bit numbers.

    @ 2010-07-02: Ok .. sorted it out, the following time limits will be enforced, and this will work for both the 32 and the 64 bit versions … hmm, not so for the 32 bit version as the total program memory allocation should stay under 2 GiB … so it's impossible to tell upfront … hmm hmm. Ok, the x32 numbers are based on an empty patch, so it will be always less than or equal to the indicated duration. Added an indicator to the module telling the true available time, or in case of an an error some error message.
    sample ratechannel countmax duration x64max duration x32
    44k1 130:00<= 30:00
     230:00<= 30:00
     330:00<= 20:00
     430:00<= 15:00
     530:00<= 12:00
     630:00<= 10:00
     727:59<= 08:00
     824:35<= 07:00
    sample ratechannel countmax duration x64max duration x32
    48k 130:00<= 30:00
     230:00<= 24:00
     330:00<= 16:00
     430:00<= 12:00
     530:00<= 10:00
     630:00<= 08:00
     725:42<= 07:00
     822:35<= 06:00
    sample ratechannel countmax duration x64max duration x32
    88k2 130:00<= 30:00
     230:00<= 15:00
     330:00<= 10:00
     423:52<= 07:00
     519:19<= 06:00
     616:13<= 05:00
     713:59<= 04:00
     812:17<= 03:00
    sample ratechannel countmax duration x64max duration x32
    96k 130:00<= 28:00
     230:00<= 14:00
     330:00<= 09:00
     421:55<= 07:00
     517:45<= 05:00
     614:54<= 04:00
     712:51<= 04:00
     811:17<= 03:00
    @ 2010-07-02: Added a feature, when %patchname% is used in the file name to save under the string %patchname% will be replaced by the name of the patch. So when the patch is called 'silly-putty' and the file name was selected to be 'C:\MyRecordings\cc_%patchname%.wav' the wave data will be written to the file 'C:\MyRecordings\cc_silly-putty.wav'.
  • 2020-07-01 : Fixed a bug for the DelayMod and DelayMix modules, the range selections were not working.
  • 2020-07-02 : I've removed the non real-time recording mode, the new recorder module is to be used instead. The non-real-time mode would stop audio generation and it would record the first two channels only. The new module can record from one to eight channels and real-time audio will keep running while recording.
  • 2020-07-03 : Fixed a bug for the recorder module where it would occasionally access undefined memory on changing channel count or duration.
  • 2020-07-04 : Added volume control to the WavePlayer and the LoopPlayer modules.
  • 2020-07-04 : Added amplitude modulation (am) inputs to all of the LFOs, except for the Tod and ClockGen modules.
  • 2020-07-05 : Added amplitude modulation (am) inputs to all of the audio rate oscillators that did not have it yet, except for the DTMF and the Phasor modules.
  • 2020-07-06 : To get better control over the modulation range for the BPM related modules (MidiClockIn, RateConverter and Tapper) I've added pivot controls to them, they set the 'center' of the modulation.
  • 2020-07-06 : Fixed a bug in the patch writer to make it write out the allowance for randomization of the DataMaker component. This implements, a.o. the graph in the AudioGraph module, for which the randomiztion allowance was not saved. The patch reader did handle the situation correctly already. The patch version was not changed for this. As a side effct the randomization allowance for some other components gets written out too now, but always with a value of 0 (zero, do not allow).
  • 2020-07-06 : Made a folder selection dialog for all the various file types that can be used in for different purposes in a patch. So can have all files neatly stuffed away in separate folders now. See the image below. It is a bit fascistoid this, I'd agree on that … the former freedom drove me mad and I'm making chocolate orange cocos icecream right now.
  • StereoNarrow - A stereo narrower 2020-07-07 : Made a stereo narrower module, it sums he left and right signals and then mixes those with that sum in a controllable way, that way fading from stereo to mono. This can also be used to zoom in on phase issues where in the mono signal left and right would cancel each other when in anti phase. The module is rate smart and will work full rate when audio rate signals get connected to it.
  • audiograph in action 2020-07-07 : Fixed some more issues on the AudioGraph module, it was not allowing randomization by default and the auto-scale feature could not be turned off. It now behaves as intended.
  • 2020-07-07 : Moved all MIDI configuration items to the 'MIDI devices' dialog, which I then renamed into 'MIDI setup'. Also changed how these settings are written into and read from the ini file, you probably will need to reconfigure your MIDI settings.
  • 2020-07-07 : Moved all OSC configuration items to a new 'OSC setup' dialog. Also changed how these settings are written into and read from the ini file, you probably will need to reconfigure your OSC settings (I've added a help button in the OSC setup).
  • 2020-07-07 : Reconfigured the Settings Screen F3 a bit to fill out the holes …
  • 2020-07-08 : Started splitting off parameters from inputs; up to now all knobs and things were treated just like inputs were (except no wires could be connected to it … although I have considered to allow for this at times), when done with this knobs and such will be params and only the true inputs will be inputs. Probably a couple of days work …. Started left with the i/o modules and sofar did 97 of 325 modules - at Modal2 now, more tomorrow.
  • 2020-07-09 : Going on with splitting, 99 done now and moving to the Mix tab. And the mix tab is done, 117 of 325. Switches were easy, 127 now, 137 after ctrl1. And after ctrl2 22 more, makes 139, still not halfway trough, let's first do some error checking now. 10 typo's fixed, and 16 more modules done, 155 now, on to the next tab: math. But dinner first and cherries and icecream!

    Things expanded a little, just passed the 300,000 lines mark again, 2 over it now. +21 for the math modules, makes 176 – more than half done (:-)

    Then 24 more for the logic tab making 200. And that was another 15 from seq1 making 215, the sequencers need a lot of attention, on to the seq2 page … tomorrow (:-)
  • 2020-07-10 : Going on with splitting, 226 done now and moving to the Gen tab. Plus 19 to 245, on to FX tab, 80 to go. 18 more to make 263, on to the Delay tab. And another 14 @ 277 now, next tab is Voice – dinner stuff first though. pwew … done, now check stuff and test stuff (:-)

    Checked all kinds of stuff … like not mixing up i_xxx and p_xxx thingies in the Params[ p_xxx], AddParam( p_xxx), Inputs[ i_xxx] and AddInput( i_xxx), and also i_xxx and p_xxx ranges MUST start at 0 and there MUST not be gaps or things will crash later on …

    I've been thinking about how to enforce this making use of strong typing, but could not think up a way that would not be clumsy (i.e. using type ins = ( i_xxx, i_yyy …); and then must have {$SCOPEDENUMS ON}, and then use Inputs[ Ord( ins.i_xxx)] everywhere) or use variables instead of constants (like var i_xxx; … i_xxxx := AddInput( 'xxx');) which would make things slower by adding an indirection level.

    Also one would like to do type TInputId = type Integer; TInput = record id: TInputId; name: string; end; TInputs = array of TInput maybe. But that would need some typecasting in places, like where the Id's go into set of's. Generics could help there I guess, but still the demand for consecutive numbers starting at 0 would be ugly then.

    So, let's just run it again (:-)

    At least there is basic functionality, an older somewhat more complicated patch seems to run okay. Not bad for after turning it inside out completely.

    Release compile works, with about the same load as before the operation. Had it expected it to be somewhat faster, oh well, it is the separation that it was done for, would have accepted somewhat slower as well.

    Anyways .. time for backups and such.
  • 2020-07-11 : Hmm, it seems to have fukt the 32 bit version somehow. Okay that was unrelated. Something something floating point exception masks mumble mumble. Those always are an interesting subject in the summer course 'how to crash your computer and have no idea why', anyways do NOT put garbage into your flotaing point exception masks.

    The 32 bit version is fine too now.
  • 2020-07-11 : Exploring the generics idea mentioned a couple of sections back:
      NO_PARM   = 'noparam';
      NO_INPUT  = 'noinput';
      NO_OUTPUT = 'nooutput';
      NO_ID     = -1;
      TParamId  = type UInt16;
      TInputId  = type UInt16;
      TOutputId = type UInt16;
      TIdNameMap<T> = record
        ID   : T;
        Name : string;
      TIdNameMaps<T> = array of TIdNameMap<T>;
    and then later on:
      TMod = class
      // Synth module prototype
        FParamMaps  : TIdNameMaps<TParamId >; // Maps param      names to Id's
        FInputMaps  : TIdNameMaps<TInputId >; // Maps input  pin names to Id's
        FOutputMaps : TIdNameMaps<TOutputId>; // Maps output pin names to Id's
    being used as:
        function    GetParamCount : Integer;
        function    FindParamID   ( anID: TParamId ): Integer;
        function    FindParamName ( anID: TParamId ): string;
        procedure   AddParam      ( anID: TParamId ; const aName: string);
        function    GetInputCount : Integer;
        function    FindInputID   ( anID: TInputId ): Integer;
      ... etc
    being implemented as:
        function    TMod.GetParamCount: Integer;
          Result := Length( FParamMaps);
        function    TMod.FindParamID( anID: TParamId): Integer;
          i : Integer;
          Result := NO_ID;
          for i := 0 to ParamCount - 1
          do begin
            if   FParamMaps[ i].ID = anID
            then begin
              Result := i;
        function    TMod.FindParamName( anID: TParamId): string;
          p : Integer;
          p := FindParamID( anId);
          if   p <> NO_ID
          then Result := FParamMaps[ p].Name
          else Result := NO_PARAM;
        procedure   TMod.AddParam( anID: TParamId; const aName: string);
          p : Integer;
          N : string;
          N := Trim( aName);
          p := FindParamID( anID);
          if   p <> NO_ID
          then FParamMaps[ p].Name := N
          else begin
            SetLength( FParamMaps, ParamCount + 1);
            FParamMaps[ ParamCount - 1].ID   := anID;
            FParamMaps[ ParamCount - 1].Name := N;
      ... etc
    Anyways, this all will still accept plain non negative integer constans, so it offers no protection at all. I must have misunderstood the:
        type typename = type something;
    construct, I'll keep it in tho for clarity towards the casual code reader.
  • 2020-07-11 : Added reset inputs to the Looper and StereoLoopr modules. When they trigger the loop pointer is set back to the start position.
  • 2020-07-11 : The folder selection does not seem to work as intended yet.
  • 2020-07-11 : Custom wire colors can change when the custom color is one of the standard colors and the rate smart module performs a rate change. Fixed this with a kludge by not allowing the user to set those exact colors, except when a choice is made for the default color, Hmm .. no good, will need a better fix. like explicitly setting a custom color.

    That was way more non-trivial than it should have been, but seems fixed now.
  • 2020-07-11 : Fixed the issue where a sped up module would not de-speep when the fast connection was removed. needed a complete clearance of all sped up stuff followed by a repeated fixup until no more work is done. It's a bit ugly, but it works, and things really need to ripple trough all the modules and wires, nothing much can be done about that. Turns out this was related to the wire coloring issue.
  • StereoPan - A stereo panner 2020-07-12 : Added a stereo panner module, will need to change the control curve a bit, panned left or right the levels are too high. With some bounces instead of clips it works nicer, makes the code look symmetric too.
          Control :=
            + Clip(
                FParams[ p_position ]
              + FParams[ p_posmodamt]
              * FInputs[ i_control  ],
          In1     := FInputs[ i_in1];
          In2     := FInputs[ i_in2];
          Sum     := In1 + In2;
          A1      := Bounce( Control, False);
          A2      := Clip  ( 1.0 - Control, 0.0, 1.0);
          A3      := Clip  ( Control - 1.0, 0.0, 1.0);
          A4      := Bounce( Control , False);
          FOutputs[ o_out1] := A1 * In1 + A2 * Sum;
          FOutputs[ o_out2] := A3 * Sum + A4 * In2;
  • MixAudio - Audio mixer redone 2020-07-12 : Changed the layout of the MixAudio module to make it more clear what belongs to what channel, this must be about the first time that a module got larger without extra controls being added (:-)
  • 2020-07-12 : An issue was reported where "at the top left of the edit screen the individual module types are sometimes grayed-out, they do get their color back when I run the cursor over them". Probably the module selector, the only things there having color are the tabs … well some module glyphs have a tad of color … so probably the tabs loosing color?

    Maybe this is related to another thing, where sometimes no tab at all will be selected in which case no module glyphs are being shown.

    Seems not related, when the program starts in full screen mode the tab colors are not set up yet when the program needs them. This is reproducable, good (:-)

    @2020-07-12 : And it was fixable too, but definitely not related to the 'no tab selected' issue, still investigating that one (it's badly reproducible).
  • 2020-07-13 : Added an option to the audio device selector window to select <nothing> for the input- or output-device (or both, but PortAudio will complain on that, thus without any devices selected it will also be impossible now to record, but otherwise nothing too useful in selecting nothing at all). When <nothing> is being selected for inputs no inputs will be opened by PortAudio, likewise for outputs. An input only setting could still be used to record audio.

    On first load with this new feature the audio devices will have to be reselected, but it will be remembered ok once that is done.
  • 2020-07-14 : Made the title fields on the pannel1, 2, 3, 4 and 5 modules larger, so they can double as patch comments, sort of.
  • 2020-07-14 : Added multiplier inputs to the Constant and MConst modules. They operate on the constant value only, not on the add input. This way they can act as a 'constant', or or as an 'add constant' or 'multiply by constant', or as your 'multiply and add' operator for simple FIR filters. Or as a single input chainable mixer.
  • 2020-07-15 : Fixed the 'no tab' issue mentiond on 2020-07-12 too, thanks Airlock for pointing out that shift+space would cause it to happen, that finally made it reproducible, and thus fixable. The fix is not perfect, as there will be a repaint glitch still, but it will do.
  • 2020-07-15 : Hmm .. fukt up the main form, so had to go back into some ill defined backup, there might be some regression isues … yuck … and the Delphi saved backups were no good at all, some very old stuff was there and some already fukt pretty recent stuff … so had to use human memory here … what a fokking mess.

    Had deleted most of the setup stuff from FormMain by accident and no Ctrl+Z was available for some reason, then did a manual save of the unsaved files, but fukt that myself (restoring the pas instead of the dfm and then doing a save), and then there were no usable Dephi backups, and I didn't do a git commit either for a while … pomtidom dom dom oliekoken dom.

    Ok, the no tab issue was refixed, and the no colors issue as well. Multiplier inputs were not affected, neither were title field changes on panels, the <nothing> things should be fine, new modules should be fine, custom wire colors, I'll need ro check those, but prolly ok … folder selection needs a check too, Reset inputs on modules should be ok, floating point issues were redone, the splitting stuf was not affected, the MIDI and OSC config changes look okay, AudioGraph should not be affected, StereoNarrower should be fine, patch writer bug should be fine, BPM stuff idem, am stuff as well, no worries about wave player mods, or recorder bugs, real time recording is gone okay, DelayMod should not be affected, recorder should be ok, the after 06-25 scope expansion should be fine no (after fixing), audio caching and x64 specific optimizations should be fine too – hmm, they were not, but fixed it.

    So. will need to check on custom wire colors, ok that got fukt too and needs be redone, ok, did that but needs a check, seems fine now.
  • 2020-07-15 : Made the Recorder module more simple, and made a new TapeRecorder module having the old Recorder functionaliry, and as the TapeRecorder is more like a delay module put it on the Delay tab.
  • 2020-07-16 : Made the recoreder record in 32 bit float format, so when it is not normalizing on disk write a heavily clipped recording can still be recovered by normalizing it externally (checked that with Reaper, Acoustica and Audacity).
  • 2020-07-16 : Added output type selectors for MConst, Monadic and Dyadic modules.
  • 2020-07-17 : Added modulation inputs to the Reverb module.
  • 2020-07-17 : (un-de-)Normalization was calcuated wrongly in the Reverb module, resulting in math exceptions in the 32 bit version, fixed that.
  • 2020-07-17 : LfoMultiPhase module makes nonsense wave forms. Ah, the warp modulation (which it does not have implemented on the user interface) was set to almost zero. Fixed it.
  • 2020-07-17 : Added a frequency control parameter to the TritoneBank, ThirdBank, TritoneSplitter, ThirdSplitter, TritoneCombiner and ThirdCombiner modules. Before they only had FM inputs with an attenuator.
  • startup screen 2020-07-18 : Changed the startup screen a bit to reflect the current version better. In the Settings Screen F3, and in the title bar, when this is enabled, some extra version info is being displayed as well now (to be able to see if it a release, debug, 32 and / or 64 bit version, stuff like that. This has no effect on the version checking option in the program, as just the basic version info (like 2020.6.24.0, for instance) is being used for that.
folder selection

in version 2020.6.24.0

  • 2020-05-30 : made double buffering for the XYScope module, it is still not fast enough though.
  • 2020-05-31 : Introduced module versioning, such that moddule autocorrection can be applied when an older module version is loaded from a patch. Had to up the patch version for this to 10. The modifications are backwards compatible in that unversioned modules will be assigned version 1, which is the current version for all modules.
  • 2020-06-02 : Changed ModQuantizer to use HighLogic inputs insteadd of Logic inputs.
  • 2020-06-06 : Added more diagnostics to logfile for opening PortAudio as it still was not clear from the current logs if the DLL was available and where it was found. The code now does a walk over the entries found in the PATH environment variable and it will print all found occurances of portaudio.dll.
  • wave viewer loops 2020-06-11 : Made some new code to be able to read more wave types, for now it supports WAV, AIFF, AIFC and SF2 (sound font) files with arbitrary sample rates, arbitrary channel counts, and sample depths of 8, 16, 24, 32 or 64 bits for integer samples and sample depths of 32 or 64 bits for floating point samples.

    Also it can support (multiple) looping regions now [with repeat counts], regions and labels.

    Wave compression is not being supported and sample rate conversion is currently not being applied.

    wave viewer sf2 When present in the WAV file it can read an ACID section too, I've not seen such information yet in AIFF or AIFC files, so no idea how to get that information from those file types. Also loop info in those file types is incompletely written by the wave file editors I've used so far. SF2 files seem to have such information on a per sample base, still need to parse that out in some way though. The MultiWave base class I've made has some flexibility in it for actual modules to make use of such data.

    Not sure yet as to how this will affect what modules and how, a work in progress it is.

    2020-06-12 : Made a display for it too .. it's a bit small all, but for simple loops it would do I guess. To speed things up a bit I started using peak files as otherwise painting the wave takes ages. It still does take ages, but just once so now, after the wave was first used or after it got changed. Peak files are saved into a sub folder (wren-peaks-23A396E5-4A4A-42FB-90B6-3FCA46862F3F) of the folder where the wave or aiff was found, and it will have the same name as the wave it was obtained from with an appended file extension of .wren-peak-23A396E5-4A4A-42FB-90B6-3FCA46862F3F, .guessing those names will never conflict with anything … When the folder can not be created or when it is not writeable no peak file will be used and there will be no warnings, it will just be slow.

    The module shown is just a thest thingy for the new wave stuff, still not sure what exactly to do with it all. something wih looping I guess …

    Not sure yet how to deal with sf2 (sound font) files, for existing wave based modules the contained samples are just being concatenated, but there is room for better stuff I think … I can think up …
  • 2020-06-07 : Just passed the 300,000 lines of code mark.
  • 2020-06-15 : Changed the WavePlayer module to use the new wave file reading code. This means that it will now read WAV, AIFF, AIFC and SF2 files (but it will just concatenate all the samples from the sound font, and it will assume all the sample rates to be the same, the rate of the first sample will be used; loop points are being ignored) with arbitrary sample rates, arbitrary channel counts, and sample depths of 8, 16, 24, 32 or 64 bits for integer samples and sample depths of 32 or 64 bits for floating point samples. Wave compression is not being supported. Sample rate conversions are not being applied, however the playback speed will be adjusted when the system sample rate changes.

    This also means that the Mono / Stereo selection got lost; Mono files will now output on both L and R outputs, and when the wave has more than one channel the first channel will be played on the L output and the second one on the R output. Any further channels will be ignored.

    Furthermore waves will be amplitude normalized when read in, no DC offset correction is applied on normalization. And sample memory size got limited to 128 MiSamples (which for a stereo file will result in 2 GiB of memory being used, all wave data is being kept in memory as 64 bit floats).

    Changed the WavePlayTrig and WavePlayTrig2 modules in the same way.
  • 2020-06-15 : Removed the Wave Audio dependencies from the project (using the code mentioned above). And now it's under 300,000 lines of code again ( and about 20 kB smaller for the resuling executable – it is always amazing how little gain is being obtained from removing code vs. how much a little extra code costs, there must be some law for that).

    Anyways, ready now for some new sample based modules, but first the 2020-06-20 june solstice concert … with existing modules and functionality, more changes after that … best.
  • 2020-06-23 : Now that the event is out of the way … Started working on a 64 bit version, found some odd bugs that I fixed and it seems promising sofar … not yet working is the freeverb reverb module, as it has some 32 bit assembler code in it. Will have to run lots of tests now – and checks for (in)valid type casts and int sizes and such. It runs the current patch I was working in almost half the CPU cycles … hmm … let's say 60 to 66 %, and also PortAudio will now discover 64 bit ASIO drivers (ReaRoute in this case). So, some promising results sofar.

    Sofar tried to open like 20 larger old patches, except for the now fixed scala bug and the reverb that needed a fix they seem to all run fine.

    The executable size is somewhat larger, as is the memory footprint of the program.
  • 2020-06-23 : Rewrote the Reverb module to not use ASM anymore and to work with doubles instead of singles. it now works in the 64 bit version. It also seems to sound way better, odd.
  • 2020-06-23 : Fixed a bug in the Scala lookup routines where a negative notenumber would cause an exception to occur. Also fixed a bug where an exception would be raised when a scale or mapping file did not exist, or where a mapping got set before a scale was set.
  • 2020-06-23 : The SAPI speech module seems broken, not going to fix that as eSpeal can do it all too. Oh and eSpeak still works with the new 64 bit DLL. Opps wrong … SAPI still works too, my test code for it failed instead.
  • 2020-06-24 : Made new compiles for the PortAudi DLL for Win32 and Win64 both in debug and relesae versions. Both versions have FL Studio ASIO blacklisted. Anyway, both the 32 and the 64 bit Wren version can co–exist now with FL Studio using the FL Studio ASIO driver.

in version 2020.5.30.0

  • Midi8NoteIn - A new MIDI multi note input module 2020-05-29 : Added a new midi in module, Midi8NoteIn, a copy of the MidiMultiNoteIn module but with a maximum of eight channels instead of four. The actual channel count can be set with the max. notes control.
  • 2020-05-29 : There was a bug in the MidiMultiNoteIn and the Midi8NoteIn modules, the mode input got never processed. Also had some doubts about how note off messages were being processed, so changed the code for that a bit too.
  • 2020-05-29 : There was a bug in the internal MIDI send code where sending to internal channels (ic1 to ic16 (from all of the MIDI send modules), to modules in the patch directly) did not work correctly.
  • 2020-05-30 : Some more issues with the MidiMultiNoteIn and Midi8NoteIn.

    I've combined the code for both with the MultiNote in using a fixed channel count of 4 and the 8Note one using a user settible limit from 1 to 8. Consider MidiMultiNoteIn to be obsolete, it will have the same performance as the 8Note one set to a 4 notes maximum.

    I've changed the scheduling for note-offs to find the oldest same valued note present to turn off. For aftertouch the youngest same valued note is used to apply the aftertouch to. This does not change the channel selection used for note-on events, for those the selected algorithm will be applied always.

    Fixed an issue with AfterTouch and ChannelPressure not being in range [0.0,1.0].

    Fixed an issue with PitchBend not being in range [-1.0,1.0].
  • 2020-05-30 : the MidiNoteIn, MidiMultiNoteIn and Midi8NoteIn modules did not correctly handle note-on events with velocity zero, it is now treated as a note-off event.

    The MidiNoteOut module can still send note-on events with velocity zero.

in version 2020.5.27.0

  • 2020-04-23: Added a random walk shape type to the LFO modules. The step size for the walk can be set with the warp controls, a low warp value giving a small step.

    Done: for the next release must update the skin stuff for this.
  • 2020-04-26: Made it possible to turn off the patch hints (the ones popping up for knobs and buttonss and such). This to "solve" a nasty issue with wine where the hint windows "hang" and that I do not know how to properly solve. It is a setting in the Settings Screen F3.
  • 2020-04-27: Added some extra controls to the OscTrig module to make it more suitable for Pulsar Synthesis like effects. It now has phase modulation, shape modulation and warp control just like the main Osc module has them.
  • 2020-04-28: Added an output type selector on the Osc and OscTrig modules, to make them more suitable for AM (amplitude modulation) type modulation (instead of RM, or ring modulation).
  • 2020-04-28: Added a modulatable repetition count to the WavePlayer2 module. This to be able to play bursts of short samples. This is also meant to make Pulsar Synthesis easier to accomplish.
  • 2020-04-28: Made two extra inputs on the WavePlayTrig2 module for programmaticly switching the retrig– and the loop–mode.
  • Seq16Rep - A new 16 step sequencer 2020-04-30: Made a new sequencer type (Seq16Rep). This is an extension of the seq16 type where a repetition count can be set for each step (1 to 256 counts). Also a trigger pattern can be selected from n(one - no trigger pulse), s(ingle - one pulse per step), a(ll - one pulse per count) and g(ate - one long pulse over all counts). The repetition count and pattern are modulatable per individual step.

    The Individual trigger outputs (trigs) as well as the main trigger output (trig) will output the selected trigger pattern, the tr. chain output will trigger once for every next step being taken, this can be used for chaining up another squencer such that it can stay in sync.

    Pulse length for trigger pulses can be changed by changing the duty cycle of the the incoming trigger pulse.
  • 2020-04-28: Added a new range for envelope times, the vfast range. it runs from 50µs to 10ms. This applies to all modules that work with changeable envelope timing ranges, those are: PulseDelay, EnvARRetrig, EnvAHD and EnvADSR. The granulators still use fast, I'm considering changing that to vfast to make them more usable. Anyway, audio rate envelopes are pretty nice for Pulsar like Synthesis.
  • 2020-05-01: Added two new signal types HighLogic (orange, audio rate) and HighLogicCtrl (dark green, control rate). These will be used on inputs only (so there will not be wires in these colors). The difference with the regular logic signals (yellow and lime) is that the latter switch for levels > 0.0 and the new types switch for levels > 0.5. This makes it easier for some logic inputs to be controlled from unipolar signals. There had been a couple of existing modules already having the new behaviour, for those modules the colors have been changed to the new colors to make the input type clear.
  • 2020-05-01: Added ranges for granular times too now, it supports the fast and vfast modes (as they existed for envelope times already). The bloody things need more work though as they still sound no good.
  • 2020-05-05: Added relative LFO rate control (r.rate) for setting a global LFO rate multiplier. This is currently not being used anywhere, decided to do MIDI syncing in a more modular way. Oops, correction .. it actually does work as a global LFO rate multiplier, but it does not change the scaling of the delay lines.
  • 2020-05-05: Made some changes to the Tapper module. An extra control mode was added (LFO fast 0.254) to allow for faster tempos with an LFO set to fast range. Some internal clipping was removed to allow for larger BPM ranges. An external tap input was added so this module can now be auto-tapped from an LFO (prably set to run in BPM mode for exact BPM matches) or from a ClockGen module's * 16 or * 96 output. The order of the control modes in the selector was changed, so some older patches may not be compatible without manually correcting the mode(s).
  • MidiClockIn - A MIDI clock receiver 2020-05-06: Made a MIDI clock receiver module, click on the image to see the docs for it. It is to be used for MIDI clock synchronization. The sync output will give a short blip once every measure (24 PPQN is assumed and 4/4 mode).

    Had to modify the overal MIDI reception structure for this, will have to test (N)RPN receivers after these changes.
  • RateConverter - A rate converter module 2020-05-06: Made a RateConverter module, click on the image to see the docs. It is to be used for synchronization of LFOs and delays.
  • 2020-05-07: Added alpha and hysteresis modulation to the CuClipStereo module, just like the mono version already had it.
  • 2020-05-10: On Sequencer reset (Seq16 and Seq16Rep) the first step should become active immediately. Changed some things for it, seems better now.
  • 2020-05-13: Added rate multiplier modulation to the MidiClockIn and Tapper modules. The RateConverter module already had this.
  • 2020-05-13: Added a sync divisor to the MidiClockIn module.
  • 2020-05-13: Added XFade modulation to the Mux module.
  • 2020-05-13: Added an inhibit (inh) input on the EnvAR and EnvARRetrig modules, when it is active the envelope will not be started. This is a HighLogic input, it will be active for signal levels > 0.5.
  • 2020-05-14: Added output type selection for the Noise and NoiseTrig modules (bipolar, positive only etc.). Some are redundant, like the pair 'positive only' and 'inverted positive only', which would end up being 'identical' in the long run.
  • 2020-05-15: Changed the grain modules to use a mixing buffer for sample insertions, this smooths out the discontinuity between the oldest and newest sample in the sample buffer and so makes grain playing less glitchy. I've set the mix area to be 16 samples long which seems to be sufficient, it is a bit of a trade off, a longer fade area makes it substantially slower (limiting the maximum grain count to be used).

    Did that same thing for the GrainDelay module, but that one still seems a bit glitchy …

    Also removed a bug where the grain duration could become zero, which caused a division by zero.
  • 2020-05-15: Changed clipping of the main program window on program load to allow for it to be sized to the screen size (without it being maximized). It used to be clipped 20 pixels short of that (unless it was maximized).
  • 2020-05-15: Removed the slave output from the RateConverter module, it was only passing on it's input – so not too much use for it. (note to self: some patches of the last 10 days will need repair for this).
  • 2020-05-16: Had fukt up the (trig) noise for the regular bipolar output range, fixed that.
  • 2020-05-16: Added 'dust' as a new random signal type for the Noise, NoiseTrig, NoiseLFO and NoiseLFOTrig modules. It consists of randomly timed spikes, the distribution over time is set by the color controls. This is after an idea obtained from SuperCollider – via the Hetrick Dust module for VCV. I've changed the implementation a bit to use two independent noise values for spike–distribution and –magnitude. This is unsynced dust.
  • ValueSync - A value synchronizer 2020-05-16: Added a ValueSync module, a value synchronizer. It acts a bit like a sample and hold but it will pass on the value captured when the pulse input got active only when a sync signal was seen after that. The Q ouput will go on for 1ms after a sync occurred, the captured value will be held untill a new pulse and sync sequence was seen.
  • 2020-05-17: Added 'crackle' as two new random signal types for the Noise, NoiseTrig, NoiseLFO and NoiseLFOTrig modules. There are two versions Crkn for the normal and Crkb for the broken mode. The ideas comes from the HetrickCV Crackle VCV module (and originally from SuperCollider).
  • 2020-05-18: Added an active output on the MidiClockIn module, intially or after receiveing a MIDI Start or Continue message it will be on. It will go off on receiving a MIDI Stop message. When active is offthe latest calculated BPM value will be set to zero and there will be no further sync pulses on the output. However the control and slave outputs will be frozen to where they were, so everything controlled by it will keep running as it was. When started again the sync output will go active briefly.
  • 2020-05-18: Fixed a bug in the global LFO rate setting. All displays of LFOs would react correctly but the actual tate was never acted upon. It now works as intended, but at some later stage I might also want to alter delay times and envelope times.
  • 2020-05-19: Added sequence length modulation to the Seq16 and Seq16Rep modules. The parameter value is being multiplied by the preset number of steps and can make the actual step count both larger and smaller, however the range will still be 1 to 16 steps.
  • 2020-05-21: For the ModGateSeq module the gate modulation inputs were changed to HighLogic (dark green, switching at 0.5) mode.
  • 2020-05-21: Added some functionality to the slew module. Slew can be modulated now and up and down slew have been separated to allow for a different change rate in one direction than the other.
  • 2020-05-26: Added a new signal type to the LFO modules, calling it the 'Random Block' mode. It will produce random levels of random duration, but changes will always be synced to the LFO rate. The chance of change to happen can be set with the warp controls, more warp makes a change more likely. When this signal type is differentiated with one of the Dif modules or wirth the ChangeDetector the result will be a sort of 'synced dust'. The 'dust' type signals from the random modules are unsynced.

in version 2020.4.13.0

  • 2020-02-28: Changed file formats to all (except MIDI files, which are binary) use UTF-8.

    Worst case, that is when you have used non ASCII characters in file names or module names, this may cause Wren to not start up anymore or to not be able to quit. Save your current Wren directories before upgrading to this.

    I've tried to program a fix for this to make things backwards compatible, but can not oversee all possible situations. In case you see any trouble please report ‐ what will fix it is removing the wren.ini file, but I'd prefer to provide a solution without history loss.

    I ran into trouble with the previous version when I wanted to save a patch with a greek name which was not handled correctly. The new version of Wren handled all migration issues for me – YMMV … let me know please – and I'll fix it.
  • 2020-04-13: Made builtin MIDI, making the NetMidi program obsolete.

    MIDI port selection is trough a new menu item setup/MIDI devices (the audio setup menu item was renamed to setup/Audio devices). MIDI Channel selection and (N)RPN preference setting still works trough the Settings Screen F3.
  • 2020-01-18: Made steps modulation on the Quantizer module.
  • LUT - Step value modulation for LUT 2020-01-18: Made step value modulation to the LUT module. This transforms it into something inbetween a constant step and a piecewise linear step processor (depending on the setting of the fade control). The modulation inputs are set to 1.0 when not connected so in that case the old generator only behaviour is maintained (modulation inputs are being multiplied by the slider set step values).

    Also added an AM input, affecting all outputs but not acting on the chain input and also not active when the module is in Note mode.
  • 2020-01-18: Changed 2010 to 2020 in places …
  • 2020-01-22: A new module, a double pendulum simulation.

    This resolves the [2017-08-12 : Double pendulum] request.

    This module can either be free running or clocked, it will be clocked when something gets connected to the clk input. The m1 / m2 control sets the mass ratio DPendulum - Double pendulum simulation between the masses at the ends of the pendulum arms. The sum of the masses is set fixed to 20 kg. The l1 / l2 control sets the length ratio between the lengths of the pendulum arms, the sum of the lengths is set fixed to 20m. The speed control and it's modulation input set the simulation step size, the simulation will not proceed when the speed is zero. For negative speeds the simulation will run in opposite direction (but gravity stays as it is). For large speeds the precission of the simulation will diminish and somewhat longer runs may result in non–chaotic behaviour. The reset input or button can bring the module back to it's starting state. With the G mod. input gravity can be changed, it can be made negative too, unconnected this input will have a value of 1.0 for standard downward gravity.

    dpendulum animation example
    DPendulum animation example
  • 2020-01-23: Changed mazes.4th to version 1.1 - just a color change really. Must not forget to use this one for the next release (it is in the web folder already but needs to be put into the zip-yet-to-be-created.
  • 2020-01-23: There is an issue with the LUT module, xfade is not working correctly when the postion wraps back to the first one. Also outputs 2 and 4 seem to behave different than outputs 1 and 3? Hmm, nope, all ouputs act the same, so that bit is ok.

    XFade is working correctly after all. As it can not look into the future it can not know that the position will wrap back in the next sample. So I've declared it to be a "feature" instead.
  • 2020-01-23: I've changed the triangular wave forms to not use integration anymore but to use a BLAMP'ed trivial waveform instead. This behaves better with wave warping.

    Changed the default bandlimiting to 1.004, close to 1 (which works best overall (it was set to 1.5 or so by default)).

    Affected modules are Osc, MultPhaseOsc, MultiOsc, OscTrig and SquareTrig modules.
  • 2020-01-27: A new module, a dual filter. DualFilter - Double filter Two 12 dB/Octave filters with three selectable configuarations and frequency spread control and pre/post distortion.

    The two filters are connected in series, the first filter frequency is set with the frequency controls and the second filter follows it with a modulatable separation offset (which can be negative by using the separation modulation inputs).

    The filter mode can be set to low pass (lp), high pass (hp) or band pass (bp). In low and high pass modes it will act as a 24 dB / oct. filter where the resonance peak can be split in two by the separation controls. In band pass mode there are two 12 dB / oct. filters where the bandwidth is controlled with the separation controls.

    The lev control sets the input level and there is pre and post filter distortion available.

    The Q control sets the filter Q for both filters, and it can be modulated positively and negatively trough the two modulation inputs.
  • 2020-01-30: Added a divider on the clock out of the Seq16 module. I'm using this for chaining Seq16 modules at a different rate than it's "natural" rate (as set with the number of steps). This would save an extra divider module.
  • 2020-01-31: Added a multiplier input to the PitchShift module, it is multiplied by the shift parameter to, for instance, allow for quick zero to set value jumps or for set value to minus set value jumps.
  • 2020-01-31: Added "add" inputs to the Constant and MConst modules. They can provide a value to be added to the output value.
  • 2020-02-13: A new module, a fast mode LFO. FastLfo - Fast LFO It is fast in that it is computed at audio rate instead of control rate, but otherwise it is the same as the LFO module. This module can be used to control delay line time modulatuion with less zippering than would be caused by using the standard LFO.
  • 2020-03-05: A new module that does … nothing … Noop - Noop It is handy at times for routing wires. and it adds one sample of delay. Just a bit cheaper than a mixer or something you could use for the same purpose. Besides, every program environment needs it's nop 😉
  • 2020-03-19: A genome player module, translating RNA strands into control signals. GenePlayer - Noop This module scans text files for A, C, G and T (or U) characters (case insensitive) and builds a sequence from those with the letters mapped to the numbers 0, 1, 2 and 3 (such that A and T (U) are complemental, as are C and G). U is treated as if it were T.

    Additionally W, S, M, K, R, Y, B, D, H, V and N are recognized, these are (according to their rules) randomly translated in one of A, C, G or T. W into A or T; S into C or G; M into A or C; K into G or T; R into A or G; Y into C or T; B into C, G or T; D into A, G or T; H into A, C or T; V into A, C or G; N into A, C, G or T.

    All other characters (including Z, white space and numerals) will be skipped.

    On playback the letters can be chained into groups of size 1 to 7 (3 would be the central dogma, codons encoding for amino acids (of which some may not exist for random letter sequences, but this module will assume existing sequences)). For a single letter there are four values [0.0, 0.25, 0.5, 0.75] or [0,0, 0,33, 0.67, 1.0] on the scaled output; for a group of two the values woud be [0.0, 0.125, 0.25, 0.375, 0.5. 0.625, 0.75, 0.875] (or their scaled equivalents).

    On each trig the next group will be output, when the unit is in repeat mode it will jump back to the start when everything was played and when it is in once mode it will stop at the end. The res input will reset the sequence to the beginning. The changed output will fire when a value change on the output was seen. The leftmost outputs are complement outputs, for ease of implementation just 1.0 - output.

    That sars2 thingie was a tad boring though to listen to … oh well …

in version 2020.1.18.0

  • 2020-01-16: Embarrassing bug … there are anti aliasing errors in various oscillator modules when PWM or Warp is not set tp 50% (extra aliasing was added instead …). Also the PWM modulation does not work as intended on the PWM enabled modules. The affected modules are Osc, Square, OscTrig, SquareTrig, MultiPhaseOsc and MultiOsc.

    Fixed all of this but the MultiOsc lost its PWM control in the process. It did hower get warp control instead which does PWM too except that the parameter names are different so some repatching will be needed on that.

    Checked LFO PWM as well, which seems to be fine.

    The Square, Saw and Tri waves sound a lot better now and PWM works as intended.
  • MixS2to1 - Solo controls on S2to1mixer 2020-01-09: Added solo buttons and a solo chain input and output to the MixS2to1 module. Making solo active on the left or right pair will block the audio chain inputs and and it will also block the other audio input pair. Also the solo chain output will then be active which is signalled by a yellow light. When the solo MixS5to1 - Solo controlson S5to1 mixer output is connected to a downstream MixS2to1 module that module will block it's local inputs and it will pass on only it's chain inputs. This will be signalled on that module by having an orange solo light.

    Did the same thing for the MixS5to1 module.
  • EnvARRetrig - A and R mod modes on the EnvARRetrig 2020-01-10: Added add, subtract an multiply modes for the A and R times on the EnvARRetrig modules. These control how the modulation inputs will act. In add mode, which is how things currently work and which will be the default setting, the modulation input value is added to the knob value to determince the actual time used. In subtract mode the modulation will be subtracted from the knob value and in multiply mode (which is how the modulation once a long time ago worked - and I wanted to have that again) the modulation input will be multiplied with the knob setting to determine the actual time.
  • Osc - Wave morphing on OSC module 2020-01-13: Added wave morphing to the OSC module. The morph input signal is being multiplied by four and then added to the wave selector control value. From this two waves are selected ( sine, tri), ( tri, saw), (saw, square) or (square, sine) and a mix from those two will be sent to the output, proportionally to the morph input value. It is the red input left of the wave selector.
  • 2020-01-15: RandSigs - Clipping for RandSigs module Added scaled clipping control to the RandSigs module. This to be able to make it spend more time at it's extreme values, which may result in more interesting volume patterns, for example (when used for volume control).
  • 2020-01-16: Added pluck level modulation (AM) to Karplus-Strong based modules (KS and Pluck); Added AM input to HrastFilter (and made it a bit less high - pixel wise); Added AM to the HrastOsc. Added AM on SVF flter input; Moog filter, idem. Also AM now for Square, OscTrig, SquareTrig modules.
  • 2020-01-09: ModGateSeq - A modulated gate sequencer Added a modulated gate sequencer, the modulation inputs can enable or disable a sequencer step. That is, a step manually set to one of the active modes can be turned off by setting the mdulation to zero or smaller. When the modulation is above zero a step set active by the buttons will be made active. Unconnected modulation inputs are set to one, so then the step will follow the button setting.

    Steps that are turned off trough the modulation inputs will flash orange instead of yellow. They will not be skipped, but they will not pulse the output.
  • 2020-01-15: ScaledClip - A scaled clipping module Added a scaled clipper. The input values are first being level scaled according to the input type setting. Then they are being multiplied by the set level (level knob setting multiplied by the level modulation input) and clipped into a [-1.0,1.0] range. Finally the signal is being rescaled according to the selected output type.

    The idea is that signals clipped this way will spend more time at their extreme values, i.e. a saw shaped input will be output as a trapezium shaped wave. But it can be used for all sorts of input values to make them spend more time at the extreme values.

in version 2020.1.6.0

  • 2020-01-03: There are some issues with the TextWriter module (considered to be fixed now):

    Changed the TextWriter module to allow it to only write into an existing folder. Also made it so that the text file will now be rewritten when the prefix settings changed.

    When the folder would not exist (or maybe be located on a disconnected network drive) patch changes would get very slow while windows was looking to find the folder. The requirement for the folder to exist is assumed to solve this issue.

    This will not work when windows still thinks the drive to be present, which happens after network issues. Sometimes it will come back, sometimes it will not in which case opening the drive in explorer will help – mostly.

    Added an option to the Settings Screen F3 to allow the TextWriter module to work at all. By default the mechanism is disabled, so if you've used the TextWriter module before you'll now have to explicitly enable it.
  • 2020-01-06: Delay times for the DelayMix module were not set properly, fixed.
  • 2020-01-06: Added three extra delay ranges for the Delay, DelayMix, DelayStereo, Delay8, RndGranulator, Granulator, SimpleGranulator, GrainDelay, Looper and StereoLooper modules. Actually the ranges are the same, but there are 8192 steps instead off the 256 for the existing ranges. This allows for more precission in setting the delay time. All displayed time will show one or more extra digits too now, not only for the delay modules but for all modules displaying time.
  • 2020-01-06: Upped the patch version to 9 to handle the changes made for the delay times properly. Older version patches should still be read properly. The displayed values though will have one or more extra digits, so things may look a bit different (like 110 ms in the medium range will now be displayed as 109.9 ms, but it still is the same actual delay time). This affects not only the delay based modules, but all modules capable of displaying time (like LFOs and envelopes, for instance). I've changed the display widths a bit for the longer representation to fit.

in version 2020.1.1.0

  • Sometimes it would happen that wire speed fixup was not processed correctly. The ouput module, for instance, would have blue input wires making things sound bad (as the signal would be control-rate then). Put a patch on this which seems to fix it, but it is a bit odd all … it depends on the order wires are drawn, a blue <- blue <- blue <- blue <- red chain should be transferred into an all red chain, but sometimes the leftmost two would stay blue. Fixed now.
  • There is a bug in the HardClip module, and maybe in other modules having the Lock option too. When Lock is set to off, on reloading the module the high level will be set to the inverse low level (which should only happen when Lock is set to Mirror Mode. In the Off mode the high an low levels should be independent.

    Solved it by setting the default pairing mode to off instead of mirrored. All other modules with paired knobs already had the default mode set to off. Things will work okay when the pairing mode is turned on in the patch (on the module) itself.
  • When on the module selector the number of tab button rows gets larger than two, modules become mostly invisible and can no longer be selected. To change this I have made the program check for the number of rows and when it gets larger than two the width of the selector will be accomodated to reduce the number of rows to two.

    This will not change the layout when the number of rows was one or two.
  • Fixed a bug in the "new patchname template" where the $N macro was not treated properly.
  • Changed the way module registration conflicts are handled. This used to cause the ini file to be corrupted, not so anymore (an issue encountered mostly during development of new modules).
  • Fixed the text color for the TEdit components on the Settings Screen F3, to make the text more readable. Default is white on grey now, the actual colors are user selectable (edit font color, under colors).
  • Made it possible to hide groups of controls from the toolbar. When made vissibe they will still be in a pre‐determined order. This can be set from the Settings Screen F3, but also there is a popup menu for it on the tool bar as well as there are items for it in the view menu.
  • Got a bit much going on in the OSC tab in the module selector, split it up into OSC1 and OSC2 tabs. Also rearanged the oscillators a bit better by category.
  • Added a freeze input to the Delay module. It will mix the fixed output and the input and that mix will be the actual input to be recorded into the delay line. When unconnected the module behaves as it ever did.
  • Added A, D, S and R lights on the ADSR module, likewise for A, H and D on the AHD one. And then added A, H and R lights on the two AR type envelopes as well.
  • Added an amplitude modulation (am) input to the GVerb module. When not connected it's value is 1, and it is being multiplied by the in level value to set the input attenuation.
  • Added a "1" output on the GateSeq module, it will be active when the sequencer is on it's first step.
  • Made a shuffle input on the seq16 module, it will randomly swap some slider values when activated.
  • Added an End Of Cycle (eoc) output to the EnvARRetrig module. Feeding it back into the trigger input will turn it into an LFO. It can also be used to make a sequence of triggered envelopes. The eoc output will only fire when the envelope curve was completed, so when the module is triggered too fast for completion to occur (it retriggers) this output will not go active.

    Added the eoc output to the EnvAR module as well. This module will not retrigger so it will always complete it's cycle and so eoc will fire always.
  • Added an AM input to the filterbank modules.
  • WavePlayTrig - A triggered wave player Added a triggered wave player module, and a variation on it with variable start point and duration and some more control over the parameters. These are level triggered modules, the sample will start playing once the trigger input goes within the range set with the trigger level and the trigger range. This makes it possible to fire samples from a saw shaped LFO, each at its own time.

    There is a loop mode setting allowing the wave to be played once or repeatedly (as long as the trigger condition is met). The trigger mode can be set to normal or to retriggerable ‐ in normal mode the wave will have to finish before it can restart, in retriggerable mode it can be restarted while playing by making the WavePlayTrig2 - Another triggered wave player trigger condition false and then true again.

    The playback speed can be controlled with the speed and the freq and/or fm controls, negative speeds (playing the wave backwards) are allowed too.
  • Economy - A wealth distribution simulation Added a wealth distribution simulation thingie. It has a pool of 1001 clients and on every internal update clock a transaction will be performed by two clients. Clients can transact only when they have more wealth than - kappa. When they transact the transaction will be some fraction of the wealth of the poorest of the two clients. This fraction ranges from 0% to 5%. When chi (the tax factor) is set to zero this will pretty quickly explode into an oligarchy where one client has all the wealth and the rest in maximum debt (as set by kappa). When chi is upped a fraction of the value of the transaction will be transferred from the richest to the poorest in the transaction and this will stabilize the system. The total internal wealth will be equal to 1001 times the set capital value (which is capital per capita), at least after a reset was issued (when tweaked wildly this may not be true).

    On every input clock a random client is selected and it's wealth will be put on the output. Also a minimum and a maximum wealth is maintained, those values will (also when the clock goes active) be sent to the max and min outputs.

    Now all of this really makes just a fancy random generator where small numbers will occur more often than large numbers (and where larger numbers will be spread out more in range as well), and as such it might be of musical use, especially when combined with the MinMaxRange module (see below) to make the output range more predictable. But also, it seems to make a nice rainy type of noise.

    The internal update clock will either run at the sample rate or at the control rate, depending on the module being connected to a fast (red/yellow) or to slow (blue/green) modules only. The min and max values are recalculated once every 1001 internal clocks. For fast output clocking the min and max values may not always be accurate (as it could clock faster than the 1001 cycle period time). The numbers on the left show the current min and max wealth.

    1001, a thousand and one nights she sat beside the sultan's bed. But also it is 7 x 11 x 13.
  • MinMaxRange - A range scaler with min and max inputs Made a MinMaxRange module. This is a scaler module for the case where the minimum and maximum values of a signal are known (as for instance in the Economy module above). The module will transfer a signal (sig) that moves within a range min to max into a range [0,1].

    When the minimum value happens to be larger than the maximum value the module will still return valid output values, but it will work inversely (where the largest input value will map to zero instead of one).

    Signals that are outside the [min,max] range will also be handled but will end up as an output signal outside the range [0,1] .

    When the minimum and maximum values are almost equal the minimum value will be returned for whatever the signal value happens to be.
  • EqDivQuantizer - An equal division quantizer Made an equal division quantizer. An "octave" can be set which will be divided into the set number of divisions, all intervals thus created being equal in size. An "octave" of 2 is the usual octave, and 12 divisions will then create the usual 12EDO, 12TET or chromatic scale. The input range can be trimmed down with the range controls, these are common for all four channels.

    The lights will indicate errors in the entered values (i.e. values that are not understood by Wren.
  • Branches - A quad Bernoulli gate after the Mutable
          Instruments braches module Made a replica of the Mutable Instruments Branches module, or the Bernoulli gate as it is also named. The Wren version has four gates, however they share a common mode- and p-parameter.

    The module has four modes of operation:
    • normal: on a rising input edge with probability p the topmost output will be turned on and otherwise it will be the bottom one. On a falling edge both outputs are being turned off.
    • toggle: on a rising input edge with probability p the inactive output will be turned on and otherwise it will be the active one again. On a falling edge both outputs will be turned off.
    • lnormal: or latched normal, as the normal mode, except the currently active output will stay active until the other one gets active.
    • ltoggle: or latched toggle, as the toggle mode, except the currently active output will stay active until the other one gets active.
    Made the output indicators bi-color, as the Mutable one has them. Dark means both outputs are off, yellow means the top output is active and orange indicates the bottom one being active.

    The probability p is determined by the sum of the p knob and the p input. The resulting value will be clipped to a [0,1] interval.
  • RateMult - A Quare wave rate multiplier Made a square wave rate multiplier. It Takes a square shaped input and then turns every edge in it into a pulse. It does not try to square up the signal, so the duty cycle information is lost. Modules can be cascaded to get 4, 8 etc. rate multiplications (but the pulses will not be spread out evenly then).

in version 2019.11.12.0

  • 2019-11-12: Oops … made a bug in the WavePlayer which causes it to not always play, fixed it for version 2019.11.12.0.
  • 2019-11-12: An undocumented new module for Gabe to check out.

in version 2019.11.11.0

  • Fixed a bug causing occasional memory allocaton errors in the eSpeak module.

    Added a check to see if ESpeak had actually been installed by reading HKEY_LOCAL_MACHINE\SOFTWARE\Classes\TypeLib\{7192AA2F-F759-43E9-91E7-226371EF6B2F}\1.0\0\win32 from the registry, when that key is present and it's (default) value points to an existing file, it is assumed ESpeak was installed (at one time at least …). I'm not sure this will always work … this key is defined in the ESpeak source code for version 1.48.04, but it might break on later ESpeak versions.
  • Fixed a bug in the ProgDivider module which caused it to set out of range division values under some conditions. Also the divider could get out of sync when the counts were changed, that is it would get triggered on the oposite input edge, fixed this too.
  • Fixed the multiplex module such that it will no longer go out of range and also fixed the crossfading for it to work properly when less than the maximum amount of steps is set. The demultiplexer had the same issues, fixed those too.

    Added a changed output to both the mux and demux modules which will generate a short trigger pulse whenever the selected step changes.
  • Removed a handful of range errors and divisions by zero and such. Did not run with range, overflow etc. checking enabled for a a good while ‐ I should have! (after all it's Pascal :-)
  • It seems to not be possible to have a single quote character in a patch name. Something to look into. Ok, this was a patch writer issue it did not do proper quote escapement (the patch reader already did it right). The same problem would arise on module titles with quotes in it. I've fixed this for both cases. User typed string values in edit controls were properly escaped already. Now there still may be an issue with multi‐line string values … k … the patch reader would not read line‐feed characters, which is fine for everything except for the value popup editor ‐ fixed this as well.
  • When oscillators are copied from a patch into another one in another instance of Wren with a different tuning being set, the new tuning is either not being applied or not visible in the user interface. Currently the only way to fix it seems to be to alter the tuning and then undo that. This will probably apply to all tuning sensitive modules, filters for instance. Indeed, the tuning of the imported modules is applied to the patch instead of the tuning of the patch being applied to the imported modules. This will probably go wrong with importing saved module clusters from file as well. Fixed it, only loading a completely new patch will affect the current tuning parameters, and none of the pasting or module read options will do so.
  • Fixed a "bug" on the Looper and StereoLooper module where it would not output any sound until the speed knob changed position. Also changed the speed input for the WavePlayer module to have a default value of 1 (to make the wave being played without any furter connections, when you'd want a "standing wave" connect the speed input to a constant zero value).

    Later I've added a selector for the speed mode, by default it is on which makes the wave to be played at regular speed. When turned off it makes the wave stand still. When the speed input is connected to something however this will override the speed mode setting. So you can now have it function in both the old and the new way.

    When the wave stands still it can still be played by varying the pos input, for instance by connecting a saw shaped LFO to it.
  • Fixed a bug for the Constant, SeqValues, Lut and Knobs4 modules where, when the mode was set to "note", the value knobs and sliders affected by this mode would loose their value on module copy or patch reload. These were all cases where the step count of the associated control would change with the selected mode.
  • Fixed a bug for the SeqValues module where wrongly colored dots could be set on the P, S and E controls.
  • Changed the Vocoder FFT overlap from 75% to 50%, with the Hann window used 75% created some nasty squeals at 1/3 of the sample rate (which of course I didn't hear in my old ear ;-) ‐ but the spectral analyzer …

    And while at it, I made the FFT size user selectable. A larger size first will sound better afte which it tends to smear things, but also a larger size will give more processing delay.
  • Changed the WavePlayer module to always play at the same rate, indepent of the current sample rate. It still only accepts 44k1 stereo or mono wav files.
  • Made the VU meter update rate independent of the lights update rate, it is fixed now at a 23.8Hz rate.
  • Added two macro's to the TextWriter module. %patchname% will be substituted by the name of the current patch and %prefix% will be replaced by the TextWriter prefix value, which can be set trough the Settings Screen F3 ( when prepend prefix is checked it will be prepended always, when it is not checked it will be prepended only when the %prefix% macro is used in the TextWriter module ‐ the prefix value itself can be left blank too when no prefix is wanted).
  • Added an active input to the eSpeaker, when active speech will proceed, when not it will be frozen in-place. With an SR flip-flop triggered from an LFO and reset from, for instance, the word trigger out of the module, speech onset can be synced to the LFO. It will still be async while it runs, and this will cause clicks due to the abrupt starting and stopping, but at least it's synced a bit.
  • Added inverted outputs to the RangeConverter module, where the regular ones go up the inverted ones go down (over the same range), and vice versa.
  • Added changed outputs (in the column marked "C") to the seq16 module. These will go active briefly when the associated sequencer output changes.

    And also added clear inputs for "one", "some" and "all", similar to the randomizer. The some inputs will clear or randomize four steps that are separated by four steps. The starting step is chosen randomly from the first four inputs.

    Added three extra chain inputs, to make it possible to chain all four sequencer lines. Some patches may need modification (connect the original one chain input to the three new ones) for it to function the same way as it did before. This is the columne of inputs marked with "c"
  • Added an "am" (amplitude modulation) input to the basic Osc module.
  • Added an "am" (amplitude modulation) input to the Looper and StereoLooper modules.
  • Added shape warping to the basic LFO module. This acts like PWM for a square output, a triangle can be morphed from saw to ramp, etc. This works for all the wave forms, but the random waves will not be much different on warping.
  • Added a range selector to the ARRetrig envelope module. This allows for way longer times to be set for it. For patch compatibility it will come up with the default fast mode (it always had).
  • Added module feedback to the edit history window, a selected history item will now highlight the associated module in the patch editor.
  • Added a brownian noise mode to various random generators.
  • Added a Filter mode to the PulseDelay module, this will cause it to only be able to re‐fire after the input was inactive for a couple of sample times ( depending on the control rate divisor). The ouput is quaranteed to stay low for a couple of sample times after the stretch period ended. This makes it possible to set a maximum rate for the output to fire. For instance, when the input rate is 1Hz and the filter time is set to 2.5s the ouput will fire no more often than once every 2.5s, so in this case it will fire once every three seconds. This differs from the stretch mode where with the same settings the ouput would never go low.
  • PADSynth - a PADSynth module Added a PADSynth like module, it use IFFT to generate sound from a spectrum which is created by a set of faders and some extra controls for spread, peak bandwidth and bandwidth scaling with frequency. Some of the controls are clicky as the IFFT has to be recalculated (and I was too lazy to make fades for that). Also this does not fully implement the PADSynth, it just uses it's basic ideas as laid out by Nasca Octavian Paul ‐ anyways, it can make some nice sounds.

    The faders set the spectrum, the bw (bandwidth) controls set the width of the spectral peaks.

    The spread parameter manipulate how the spectral peaks will be spread.

    The module works by generating an in‐memory waveform from the spectrum. This waveform can be played at different rates and from different positions by using the position speed and frequency controls. At some stage I should modify this to have multiple wave forms to be generated with cross fading implemented over that, too lazy for that now.

    The module has a stereo output, a diffrent tap point is used that for that on the calculated wave.

    The IFFT size to be used can be set, small values will act a bit weird, anything up from 8192 seems okay. Values from 64 to 262144 can be used.
  • The 300th module :-)

    GrainDelay - a GrainDelay module Added a new granulator type module, working better than the three existing ones. It has a delay line able to hold 5 minutes of audio and a maximum of 128 grains can be set (provided that the CPU can cope with that).

    It has grain controls for pre-delay, spread (or grain distance), pan, duration, frequency, speed and amplitude. All these controls can be modulated. Additionally the amount of grains can be set from 1 to 128, and this can be modulated too.

    Several grain envelope types can be set to change the sound character: bell, pulse, exp, reverse exp, tri and box, for all of these there is a noisy variation as well.
  • Smear - a Smear module Added a smearing module … why? because I could. It smears the phase of the incoming signal with a controllable random amount and it adds some delay, FFT based.
  • MinMaxMix - A MinMaxMix module Added a MinMaxMix module after an idea from an idea from Ricko at the electro-music.com forum. When both input signals are positive the ouput gives the largest one of them. When both are negative the output is the smallest one. When the signs are opposite the sum of both inputs will be sent to the output.
  • PhaseSplitter - A phase splitter module Added a PhaseSplitter module, it will split the incoming signal into two signals that are 90 degrees out of phase. This can be used as a building block for various audio effects. for instance the Bode frequency shifter internally makes use of the same splitter code.
  • Detector - A detector module Added a Detector module, it will split the incoming signal into two signals that are 90 degrees out of phase, thus "complixifying" it. It will then use the complex signal to derive instantaneous amplitus\de, phase and frequency. This works properly only for sine shaped signals, but also "sort of" (as in "nicely") for more complex signals. I've used it to analize a voice signal to control an oscillator to implement pitch shifts on that voice.
  • AbsAdder - An absolute value adder Added an AbsAdder module, it adds up positive input values only, all negative inputs are clipped to zero. This is a sort of a "Micky Mouse" logic "OR" function, the ouput will never go negative.
  • DTMF - A DTMF tone generator Added a DTMF tone generator. It's input value range 0 .. 1 is scaled into a range 0 .. 15 which then is used to select a symbol from [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, #, *]. The symbol then is converted into two tones according to the following table:

      1209 Hz 1336 Hz 1477 Hz 1633 Hz
    697 Hz123A
    770 Hz456B
    852 Hz789C
    941 Hz*0#D
  • Sieve - A number sieve module Added two Xenakis like number sieve modules, one with a blue (addressing) input control and a clocked version.

    Wren's notation for basic modules is:

    • [n,m] : a sieve module with modulus n and residue m [3,1] -> {1,4,7...}.
    • {numbers|n} : a litteral number sequence, f.i. {1,5,13,14,21|24} n is the modulus, 24 in this example. ClockedSieve - A clocked number sieve module
    • fibonacci : the fibonacci sequence {0,1,1,2,3,5,8,13...}.
    • prime : the prime numbers {2,3,5,7,11,13...}.
    • hanoi : the hanoi disc sequence {0,1,4,5,8...}.
    • hanoipegs1 : hanoi peg sequence 1 - non alternating {0,1}, {0,1,3,5} , {0,1,3,5,6,6,7,8}.
    • hanoipegs2 : hanoi peg sequence 2 - alternating {0,2}, {0,1,3,5}, {0,2,3,4,6,6,8,10}.
    • hofstadterq : the Hofstadter Q sequence, chaotic.
    • metafib(n) : genralization of hanoi, n being the order, a whole number.
    • random(f) : a sequence of random numbers, f selects the chance for any number to be present in the sequence. 0 <= f <= 1, f.i random(0.33).
    These can be combined using the following operators:

    • + : the union of two sieves: [3,0]+[4,0] -> {0,3,4,6,8,9,12...}, the numbers combined (logical or function).
    • * : the intersection of two sieves: [3,0]*[4.0] -> {0,12,24...}, the numbers present in both (logical and function).
    • ^ : the symmetric difference of two sieves: [3,0]^[4,0] -> {3,4,6,8,9,15...}, the numbers in one but not in the other (logical xor function).
    • ! : the complement of a sieve: ![3,0] -> {1,2,4,5,7...}, the numbers not in the sequence (logical not function).
    Parenthesis can be used to enforce an evaluation order, f.i. as in (([3,0]+4,0)* fibonacci)+prime to first evaluate the left +, then the * and the right + last.

    A simplified formula will be calculated when the formula changes, or when the external period changes. The simplification does not use prime decomposition, it will compute a sequence and from that it will make a sequence of modules joined through union.

    The evaluate input will force reevaluation of the formula, this can be useful when a random module is present to obtain a new random sieve.

    Otherwise this module functions like the Values module, except that the start value will always be 0 (zero) and the end value is set by the external period. This means the input value changing over the standard range as set up with the input range selector will address all sieve values.

    The difference (top) output will output differences between sieve sequence values, in case the last sequence value was selected it will be the value of the last minus the first element (this cyclic behaviour was not present in the original concept).

    Negative numbers can not be used in sieves and the random sieve's probability control is the only floating poin number being used. The ouptuts will still use float values, as they are scaled to standard output ranges ([0,1, [1,0], [-1,0], [0,-1], [-1,1] or [1,-1].

    The simplified formula is displayed above the user supplied formula, or an error will be displayed when the user supplied formula could not be parsed.

    The currently selected sequence and diffrence values are displayed in white, these are the unscaled values.

    The changed output will go active when the ouput value was changed, the difference output may not have changed then.

    The regualar (bottom) output will be scaled such that the external period results in an internal output of 1, this can be changed then with the output type selector.

    The difference (top) output will be scaled such that the largest difference value present will result in an output value of 1, again this can be rescaled using the output type selector.

    For more information on the subject try googling for Xenakis sieve, or Xenakis sieve algorithm. It may find a 221 page paper by Dimitrios Exarchos (Iannis Xenakis and Sieve Theory), I've found that to be a very useful text.

in version 2019.6.9.0

  • [obsolete] Fixed a bug with legacy audio, it would get stuck in a start / stop loop, broke that loop ‐ audio still seems to suck though in legacy mode. I've been considering removing legacy mode completely.

    As of 2019-04-10 legacy audio mode was completely removed. Great ‐ this made patch recompilation work faster (legacy audio was started and stopped for recompiles (adding or removing modules or cables, or loading a new patch) but PortAudio is kept running on recompilation).
  • Fixed a bug for the ScaleQuantizer and the ProbSequencer modules where the initial scale after patch start was not shown correctly when scale modulation was used. It would not show the initially selected scale in the notes switches.
  • Fixed some of the most obviously wrong help items, had forgotten to update the text for some of the more recent modules.
  • tuning control Changed the patch format to include the tuning parameters that were set. The patch version did not change for this as the modification is both upwards and downwards compatible. Old versions of Wren will skip tuning parameters when present and new versions of Wren will not change the tuning when the tuning parameters are not present.

    Tuning parameters will only be read when a new patch is loaded from disk, they will never be used on parameter imports and such. They will be read when a a patch template is loaded, as this is the same as loading a new patch from disk.

    An option was added to the Settings Screen F3 to never import tuning parameters from a patch. When this is active tuning parameters are still read from the ini file when Wren is started, and tey will then be the same as when Wren was last closed. This option is on by default to be compatible with previous versions.

    Also fixed the hint popup for knobs to show the right frequency after tuning changes were made. The note names are still incorrect, but I do not have ideas about how to properly name notes in general, for instance in a tuning of say 11.21 notes per "octave" sized 2.13, say …

    I've brought the tuning controls to the main toolbar, they were in the Settings Screen F3 before.

    Then had to change the patch version from 7 to 8 anyway as I did add a couple of new LFO ranges and wanted older patches to be read with correct range values and the variations to stay intact as well, see the next paragraph for more on this.
  • Added three new LFO ranges, being fast2, medium2 and slow2. These have ranges of values mapping nicer to whole time intervals (for instance a rate of 1 Hz can be set now) and also the mapping to standard oscillator frequencies is better (for instance an LFO rate of 55 Hz can be set now now, although this will only make sense in a standard 12 tone octave based tuning with an A of 440 Hz, as LFOs are not rescaled with the current tuning). Had to change the patch version number for this to be able to read in older patches correctly.

    The new patch version is 8. There are 32 steps now for a change of a factor of two, for the existing fast, medium and slow ranges this is 24 steps. Which also means that the total span of the new ranges is a bit smaller, but of course the old ranges can still be used for the more extreme settings.
  • Changed the A and R time modulation behaviour for the EnvARRetrig envelope module, the modulation is now added instead of multiplied. Added A and R modulation for the EnvAR module as well, working the same as for EnvARRetrig. Also made the modulations to work in real time ‐ before they were sampled only when the envelope got triggerd. This will break old patches when they use time modulation for EnvARRetrig modules.
  • Added some new fuctions to the Monadic and Dyadic modules. To Monadic was added 1 - abs( x) and to Dyadic x ^ ( 1 / y). Also changed the behaviour for the case where the function can not be calculated (like division by zero, for instance). In the new situation the output value will not change from it's previous value in case of an impossebility (output used to be zero for the Monadic module and X for the Dyadic module in such cases). This may break some old patches that were based on "undefined behaviour". Also the correct function may not be loaded for old patches.
  • VitaPHoBium - Yet another life based module Added 32 row sum outputs to the LifeSeq module, just so the thing can control more and better. This was inspiered by PHOBoS, but he is using an 8 by 8 grid where each cell is a different note. This seemed a bit much for a 32 x 32 grid, so I modified the idea a bit. Also made a new 12 by 12 SmallLifeSeq, more symmetrical, with both a controllable horizontal and vertical cursor. Then also added yet another game of life module the VitaPHoBium. This one has a 16 x 8 grid where input values can be clocked in to turn cells on. This one also has X Y cursor control as well as stepped cursor control, and when the cursor lands on a life cell a note value of sorts will be output. Later added a "Skip dead" mode which will try to find the next live cell on a next clock. skipping the dead ones. When X and Y are connected but Step is not the cursor will be updated asynchroneously, and when Step is connected as well the eX and Y inputs will be sampled on an upgoing Step edge. When only Step is connected the cursor will move in a stepped way, either forwards or backwards.
  • Unclick - A declicker module Made an unclick module, this is just an averaging filter with a fixed alpha setting ‐ it is a bit cheaper than the average filter, and it will filter out the most annoying clicks without giving a lot of lag.
  • Added 'raw' outputs to the Seq16 module, they are raw in the sense that they are not cross faded. Marked the existing outputs with an X and the new ones with an R, for cross-faded and raw respectively. Did the same for the LUT module.
  • Added a changed output on the ScaleQuantizer module, it goes active briefly when the current output value is not equal to the previous one. Likwise for the poetry module.
  • Added inverted outputs in addition to the regular ones for the RandSigs module. The inverted outputs are using the same output type as selected for the regular outputs.
  • Changed the way scale modulation works on the ScaleQuantizer module, to make it look a bit less confusing maybe … For an unconnected or an invalid scale selection input the pre‐selected scale will be used. When the scale modulation is connected and it has a valid value the pre‐selected scale will not be used but the modulation in itself will determine the scale to be used. Before this the pre‐selected scale would be added as an offset to the scale modulation input. So there is no longer a need to set the pre‐selection to the first value in order to get predictable scale modulation. Also it is possible now to set the preset to a fallback value to be used in case the modulation goes out of range. In the old situation invalid modulation input could cause the input value to be passed unchanged to the output, this is no longer possible, so this change may break some older patches where this "flaw" was used as an effect.
  • Added effect modulation on the AmMod module. This makes it possible to programmatically fade between amplitude and ring modulation.
  • Dif - A differentiation module Made a Dif module, a differentiator, with a fixed gain of 1. There already was an IntDif module as well, but the integrator bit did not seem too useful to me … so made it a bit cheaper. The old IntDif module is still available as well.
  • ChangeDetector - A change detector Added a ChangeDetector module. It detects changes on it's input and it will send out a trigger pulse when a change happens. Also the value of the change will put onto an output, it can be selected whether the value of the change is taken as is or has it's absulote value being taken. This sort of is a differentiator with a built-in sample and hold function.
  • Vcps - A voltage controlled pattern sequencer Made a voltage controlled pattern sequencer, it was modelled after an idea by fonik but made it a 16 step one and addded reverse and inverse modes as well as step length modulation and random control over the slider positions. The Gain and Offset controls work with bits, so they can be used to set the step where the effect begins and ends. Hmm … not quite … but will leave it as is for now.
  • AutoQuantizer - An auto quantizer module Made an AutoQuantizer module, it samples input values clocked in on it's learn input. It will remember the note value (but not the octave value) of the last N ones, where N ranges from 1 to 64. Signals coming in on the (reqular) in input will be split into an octave and a note value and the nearest note value present in the history will then be output in the octave of the incoming value. This can sort of improvise with notes it had seen before by putting some sort of a random value into the in input. When a less random input is being used like a saw or a triangle it would output arpeggios. When the new output differs from the one before a trigger pulse will be generated on the changed output, this can be used to trigger an envelope, for instance.
  • NoteSplit - A note / octave splitter Made a NoteSplit and a NoteMerge module. The splitter splits an incoming note value into it's ocatave and note parts. The merger does the reverse thing, it NoteMerge - A note / octave merger combines a note and an octave value into a note. The octave size is obtained from the global NotesPerOctave setting. The merger is really just an adder, but still, being the inverse of the splitter I'll just keep it.
  • Queue - A queue module Made a Queue module. It remembers the latest N clocked in values (with N going from 1 to 64). With the select controls one of the remembered values will be selected, optionally providing cross fading between old and new values.
  • SapiVoice - SapiVoice, yet another speech module YASM ... this speaker uses windows SAPI voices. Right, can only get it to work in 8 bit mode and it is very slow to translate speech to text. I've made a loading indicator which lights up while the conversion takes place in the background. This way it at least is possible to go on patching while the speech synth compiles the text. Funny though how it can reasonably quickly perform a voice change, text changes take much longer. Anyways, it is more like speech than the other speech labeled modules.

    Windows is a bit limited in the number of voices it supports out of the box, to fix that eSpeak can be used. On installation you can select languages and speakers to be installed, some modifiers are supported too.

    Ok, got the sluggishness out a bit, turned out it was forever appending and partially overwriting to the same audio queue instead of renewing it. So had to destroy and recreate it instead of reuse it. Still, longish texts at high rendering rates will take a while to render, like a couple of seconds for the text from YASM to here.
  • eSpeakVoice - eSpeakVoice, and one more speaker AYASM ... this speaker uses the eSpeak voices and the espeak-sapi.dll. This one is a bit slow to compile speech too (albeit a tad faster than the SAPI one maybe), for short text it will do. It more or less provides the same functionality as the older song module, except it has a better speech quality. The module will signal speech events like phonemes, words, sentences and silence. Also markers can be placed in the text to generate user events. The user events can be made to generate an output pulse, or they can put some value on an output. The number of voices is fairly large, and there are modifiers for male, female, whisper and croak. Also … it can speak Dutch with a propperly rrrroling godverdomme :-)

    Too bad tho that the eSpeak provided voices seem somewhat arbitrarily tuned. Anyways put some tuning controls, inclusing a cents control, on the module to cope with that.

    ESpeak should be installed for this module to work, and the espeak-sapi.dll should be somewhere in the path (it can be put into the wren executable filder, for instance), the standard windows DLL search policy applies.

    I've added the eSpeak DLL to the wren package, but forgot to include it into the source zip I think.
  • Added cents values to be displayed in the popups for FM modulation on audio rate oscillators as the concept of semitones is a bit odd for some scalings.
  • Changed the way the "Freeze" indictor works on the Reverb module, it no longer shows the value of the Freeze input but the actual freeze status (which is the xor of the input and the mode selection button).
  • Made the patch compiler a bit more robust. It would on bad module or cable definitions crap out and not load the patch at all. It will now load the patch skipping the stuff not being understood. Any skips will be logged.
  • Removed the splash screen animations, it was uggly in more than one aspect …

in version 2019.3.5.0

  • Fixed a bug causing unnescessary crackling. Did this by totally removing all automation stuff ‐ it was not working anyway.
  • Fixed a bug with portaudio initialization where it was not possible to have an output only system. It is now possible to have an input-only system as well … how usefule is that ;-) But there need to at least be inputs or outputs for Wren to be able to do audio I/O.
  • Fixed a bug with reading wren.formants where the file could not be read on some windows systems with a code page differing from 1252.
  • Various small changes on several modules, and a couple of new ones. I didnt keep track of this process very well though, so … surprise.
  • Oh, the ones I do know are: Added a couple of new modules, mostly Chladni related, a generator a filter bank and an oscillator bank. Oh and the Van der Pol stuff … more info later. Also added some inputs here and there … like the "1" input on the Sequencer16 and LUT modules, these randomize one of the 16 steps (a randomly selected one) instead of all at once (which is now the "all" input). Also added an interpolating slow to fast mode conversion module, helping to get less crackle on delay line modulations when the control rate division is set high. Also made it possible to have "octaves" of a factor different from 2, this is in the Settings Screen F3.
  • Trying to port stuff over to free pascal … but that will be a while. First splitting off the engine, that would be Wrengine. It compiles and it succeeds on some unit tests (like building a simple patch and executing that). I've found DLLs for Windows, Linux and OSX too. Had it compile under all three OSes as well, but didnt do any 'real time' audio testing as of yet. Also the user interface will need to be completely redone. There may be some windows only releases still before this wil take off. Anyway, for the curious, this is available for download (in the downloads section at the top of this page), just note that it is not a synth yet but an experiment. now at wrengine.2018.5.19.
  • A little update on the above, it can now read Wren patches version 2 to 7. Not all modules were implemented for it yet though. It does not have the Swansong (there is an issue with the forth interpreter) and it does not have the Van der Pol modules (which were recently added to Wren). Now at wrengine.2018.5.22
  • And a lil bug fix for the variation values. Now at wrengine.2018.5.23.
  • Added variations, morphing and automation stuff, not finished (but consuming CPU time). Also added support for reading Wren patches and added some profiling code to check the performance of the synth engine ‐ not too bad sofar, better than the original Wren it seems:
        Running synth for 1000000 cycles
        Duration was 9099 ms : time / sample : 9.1 us, sample rate : 110 ks/s
    Which was for a patch doing about 60% for Wren at 48 ks/s (or about 80 ks/s at 100% CPU, but no actual audio i/o was performed for Wrengine where it was for Wren), and optimization mildly set to o1 and many checks on. For o4 optimization, i/o checking, range checking, assertions and debug code off it was like:
        Running synth for 1000000 cycles
        Duration was 5672 ms : time / sample : 5.7 us, sample rate : 176 ks/s
    For all cases the control rate decimation was set to 8.

    Also some small bug fixes were made, should check all the p_ stuff to not use FInputs but FParams instead … now at wrengine.2018.5.25.

in version 2018.5.18.0

  • MatrixMult - A matrix muliplier Added a matrix multiplier module. It calculates Mabcd * in → out (or a * in1 + b * in2 → out1 and c * in1 + d * in2 → out2).
  • Modal2 - A new modal module Made a new modal filter able to load presets from a text file. The frequencies read will be fixed, but an overall tuning can be applied either exponentially or linearly. Individual Q and amplitude settings are present. Up to eleven formants can be specified and the overall Q factor can be set as well. The text file read is wren.modal, and it needs to be present in the Wren executable directory for this module to work.
  • MultiGate - MultiGate module Made a new MultiGate module providing four dual input gates all performing the same selectable function. The input and output signal types can be set separately.
  • Seq32 - 3 x 32 or 1 x 96 sequencer Made a 3 x 32 / 1 x 96 sequencer. Notes can be set per step as well as an octave and a duration.

    Interpretation of the duration depends on the mode set (either free or sync). In sync mode step durations are fixed to 16 clock periods and the gate time will be equal to the duration, while in free mode the step duration and the gate time are both set to the selected duration.

    Trigger mode can be set to Trig, Gate or Repeat. Trig outputting a clock for 1/16 of the input clock period (which is 16 clocks long), Gate for the set duration and Repeat does repeating 1/16 clock pulses during the set duration.

    The three button controlled modes can also be modulated.

    Split the clock input into three separate ones so the three play pointers can move at different speeds. This will also work in 1 x 96 mode, where the first output will be the sequence proper and the other two will be canon like variations on it.

    The dir input when active will reverse the playing direction, the inv input will play the sequence upside down when active. These are global controls working on all three play pointers the same way (just like act and res do).

    The / 16 outputs output the incoming clock divided by 16.
  • VanDerPol - Van der Pol oscillator A van der Pol oscillator module.
  • VanDerPolLfo - Van der Pol LFO A van der Pol LFO module.
  • Added a drive input to the Attractor and AttractorLFO modules ‐ just like the van der Pol thingies have that.
  • Added Sin and Cos outputs to the rotator module. These can be used to control delay lines to get a leslie type effect. Also added a double sin mode * where the Cos output will actually be -Sin and where the rotation being berformed works a little different.

    [*] Or maybe it's zero sin with the minus involved.
  • Made a stereo version of the Delay module, DelayStereo. This is just two delays sharing the same delay length parameters.
  • Made the phase of the RandSig module to have a random value after reset. Also made reset to cause an immediate 'wrap' action (starting a new random cycle). Reset used to only set the current phase value to zero.
  • Retuned all of the fixed filter banks a bit in such a way that they will use 55, 110, 220, 440 Hz etc.
  • Added an option to the Pad mdule to have a user selectable background. Also added three new outputs refelcting the color of the image pixel the cursor dot is on.
  • Added four extra multiplication units to the MultipleMult module, giving it eight multipliers in total.
  • Some minor bug fixes.
  • I've moved from Delphi XE5 to XE10. The latter seems to be slowish .. but hey it's the fuuture, one can't stop that.
  • I'm totally rewriting the automation recorder. It wil use a flat model now with a track for each control, and no extra module level anymore. The user can select between recording all knobs or just a set of exported ones. Each track can have it's own graphical editor. It will also be possible to add or delete events trough that editor. Currently it is not working at all.

in version 2017.11.19.0

  • Fixed some issues with the history view and the alternate module titles. Like when a module was deleted it's history could still seemingly be undone, resulting in an error, of course. Deleted modules will be removed from the patch history now. When a new module gets inserted into the patch all modules will be renamed, this situation is handled correctly now by renaming the history items as well. When alternate module titles were active a newly inserted module would still show the regular one. Fixed that one as well.
  • Had over-optimized patch compilation a bit, resulting in patches to not always play correctly after load. A workaround is to insert a new module and then delete it again. Fixed now.
  • The Gate module was not functioning properly for a bit count of one it used two instead causing the negated functions nand, nor and xnor to not work and causing the regular functions and, or and xor to behave a bit odd. Fixed now. The one and none function modes were not affected by this.
  • Introducing Hold mode for the (non‐retriggrable) AR envelope module introduced an error making the envelope hang in the A phase, fixed that. Same thing for the retriggerable version.
  • Module initialization was changed a lot in the previous release, causing the filter bank modules to generate exceptions at initiailization time (they looked at inputs at a time inputs did not exist yet) ‐ fixed that.
  • Fixed an error in the all pass filter, it's actually working now.
  • Added some functionality to the randomization limiting. For all randomization it implements a scaling function now. For mutatation, mating and morphing it implements clipping. For clipping, when the maximum value is set lower than the minimum value (a red circle segment around the knob) clipping will be performed as exclusion, as in that the range marked as red is never being used. Likewise for randomization with reversed limits the mapping will be will be 'un-scaled', i.e. mapped to values outside the selected range. So there is no inversion anymore but exclusion.
  • ranges and morphs Added a new morphing mechanism. There are four morphs available, and each knob can be assigned to one or more morphs (and it can have a randomization range on top of that too). The active mprph can be selected from the top toolbar. Moving the knob present there will move all the morphs in that group between their set ranges. I've also added a morph control module to be able to automate morphing. This mechanism is separate from the previously existing variation ‐ or auto ‐ morphing. Knobs having a range set upon them which is not the currently selected range will show a grey circle around them, a selected range will be either blue or red. The MorphController needs to be enabled in the toolbar with the (M)anual / (A)utomated switch, morphs are either manual or MorphControl - A morph controller automated. The MorphControl module provides a base setting for the morph knob and some modulation to be applied. I've also added a switch between (A)utomated and (M)anual for the auto morph system (morphing between variations). When a morph is automated it can no longer be manually controlled, as indicated by a red dot in the controlling knob (locked indicator) ‐ as can be seen in the image above for the variation morphing knob above. For morphing there is no exclusion, it will use reversed scaling instead, i.e. morph selector going up results in knob going down.
  • PDOsc - A phase distortion oscillator Added PDOsc module, a phase distortion oscillator. It has a fixed sine shaped wave to which overtones can be added by changing the ratio parameter. It turns out that phase distortion done 'Casio style' is very similar to VOSIM. Anyway, this seems to be a nice oscillator for bass tones.
  • MultiPhaseOsc - A multi phase oscillator oscillator Added a multi phase oscillator. This is a replica of the main oscillator with three extra phase shifted outputs added. Phase shift can be set to 90 or 120 degrees ‐ when set to 120 the lowest output will be a 180 degrees shifted wave. All the wave forms of the main oscillator are present, and all outputs are anti‐aliased.
  • LfoMultiPhase - A multi phase LFO Added a multi phase LFO. This is a replica of the main LFO module with three extra phase shifted outputs added. Phase shift can be set to 90 or 120 degrees ‐ when set to 120 the righmost output will be a 180 degrees shifted wave. All the wave forms of the main LFO are present, but phase shifts on a random wave make not much sense to use (as they will be uncorrelated).
  • AMuse - A MUSE like module Added a MUSE like module, implemented from the schematics publised by PHOBoS on electro-music.com. I've left out the audio generation, the module outputs a control signal instead. I've added some extra features to it: two external inputs going to to the switches, two extra divisions, by five and by seven, added two carry outputs where the overflow from the shift register ends up. Also added an inverted output signal, and the shift register's direction can be reversed.

    The free / clocked selector controls how the output follows changes in the interval selection, they can be synced to the clock or immediate (in the schematic linked to above the changes are immediate, but when using switch selection modulation it is handy to have the changes occur synced). In synced mode the res input will be synchronized to the trig input as well. The parity generator can be switched between odd and even parity. All actions related to the shift register (parity generation, direction reversal and the W … Z switches) are inherently synced to the trig input. Using an ext input and a carry output two or more MUSE modules can be made to interact with each other.
  • Shifter - A logic shift register Added a 32 bit cascadable binary shift register. The shift direction can be set to be to the right or to the left. The cil, cih, col and coh carry signals provide the chaining functionality. The is a separate signal input whic is XORed with the the carry in signal before it is entered into the shifter. This is to be able to set up loops easily, when the XOR function is not wanted the in input or the carry inputs can be left unconnected. The free / clocked selector in clocked mode will sync the reset input to the trig input, otherwise reset will be asynchroneously. The T/G selector switches the outputs between trigger and gate mode, in trigger mode the output signal will be anded with the trig input, in gate mode outputs stay active for a full input clock period.
  • LFSR - A linear-feedback shift register And while shifting … I've also made a shifter with built-in XOR feedback (a linear-feedback shift register). The feedback taps to be used are button selectable. Parity switching is provided as well as left / /right shifting. The output is taken from the internal feedback signal, that is the signal going into the shifter. For the output Gate or Trig mode can be selected, in trig mode the output is anded with the trig input. The module can be set to use odd or even parity. An input is provided to allow for external data input, it is XORed with the internal XOR feedback signal.
    Also I've added toggle inputs, one for each tap control, to be able to change the taps programmatically.
  • MultiEnvelope - A multiple envelope follower Made a multiple envelope follower. This one is meant to be used with filter bank modules to create vocoder like effects. Attack and Release time settings are common for all detectors.
  • AnalogStack - An analog stack module No idea what it is good for .. but analog input values an be pushed onto a stack and popped from it, it's named AnalogStack. Also made a digital version of this, just called Stack, that one probably has even less use. The idea was that with a multi sample an hold module and some feedback one can make Mealy and Moore machines. With a push down stack one can make automatons of a slightly more complex class … so … since … as said no idea what it's good for, but they didnt cost much!
  • SwanSong - Swan songs A Swan song generator. This module was made after a idea posted on the electro-music.com forum, see the thread at electro-music for more info on it.

    The idea is to have a swan, and a couple of hunters chasing it. The swan can fly so it's on an arbitrary position. The hunters though must walk on the paths. The paths themseleves are created by a turtle, for which I made a forth like system to implement it.

    This module needs a forth specification file in order for it to work. It will search for mazes.4th in the application directory (which will be included in the next release). This file defines a couple of exports, which are forth words which must not consume nor return any stack entries.

    The hunters will close in on the swan on every clock pulse they receive, using the path having the (locally) shortest distance to it, with the twist that no two hunters can be in the same location (when enabled with the 'dups ok' / 'no dups' selector.

    Meanwhile the swan can be moved by applying signals to the swan X and y inputs. The output values are taken from the last angle a hunter made and the last distance it traveled (the output being larger when the distance was greater). For inputs and outputs the signal type to be used can be selected. X and Y location outputs for the hunters are available too.

    The graph is internally scaled to use an area [ 0 .. 1, 0 .. 1] and angles are scaled [ 0 .. 1]. Stride lengths are used as is, so maze defintions should use a maximum length of 1, assuming that to be the case (holds for all mazes I've made sofar) all input and output values will be in that range (unless being rescaled with the input and output signal type modifiers).

    For testing I've made a small program (SwanTester,exe, see below for a screen shot) which can draw then mazes defined in mazes.4th while showing diagnostic messages; I'm using it for designing new mazes. I will include it in the next program release. It will read mazes.4th from it's home directory, so mazes.4th and SwanTester.exe should be in the same folder.

    Added an LSystems thingie to make it easier to copy interesting mazes from the webs. Like for instance a Penrose tiling as :
      LClear " C" " Clear DefaultLooks"         LMeaning
      " M" " OA++PA----NA[-OA----MA]++"         LRule
      " N" " +OA--PA[---MA--NA]+"               LRule
      " O" " -MA++NA[+++OA++PA]-"               LRule
      " P" " --OA++++MA[+PA++++NA]--NA"         LRule
      " A" " "                                  LRule
      " A" "   1.0 Forward"                     LMeaning
      " +" " -36.0 Rotate"                      LMeaning
      " -" "  36.0 Rotate"                      LMeaning
      " [" " >s"                                LMeaning
      " ]" " s>"                                LMeaning
      " Penrose" " C[N]++[N]++[N]++[N]++[N]" 4  LSystem
    An LSystem will be translated to forth source code which then will be compiled into the forth system. The LMeaning defintions mapping semantics onto the LSystem commands, and the LRule definitions define the system. At the end the LSystem definition specifies a name, an axiom and a recursion depth. The generated forth will be marked with the export directive, making the system visible for the SwanSong module. Any valid forth code is acceptble in the LMeaning definitions.

    Added maze type modulation for dynamic maze seletion.
  • Values - A values quantizer Made a values quantizer module. Mainly to be able to add selective modulation for the SwanSong module, but it seems a handy thing to have anyway.

    In the values box a number of comma separated values can be entered. The first and the last value are not being used to generate output values but they define the number range to be used.

    This range will be maped to an internal output range of 0 .. 1. Also the mumber of values is counted (minus 2 for the unused last and first values), and this value will be mapped to an internal input range of 0 .. 1.

    Now when the internal input value is 0 the first element of the value list (which is the second number in the list) will be selected, and when it is 1 the last element (which is the one but last value in the list), and for input values between 0 and 1 numbers between the first and last will be selected.

    The selected number will then be translated to an output value using the determined output scale.

    An example : say you enter 0, 0, 1, 3, 4 into the values box, so there are three values (0, 1, 3) and the range of values is 0 .. 4.

    The input mapping then is such that input values of 0 .. 1/3 will result in the first value of 0 to be selected, likewise 1/3 .. 2/3 select the value of 1 and 2/3 to 1 will select the last value 3.

    Now the selected values will be scaled too, such that the range 0 .. 4 is mapped to a range of 0 .. 1. So the selected value of 0 results in an output of 0/4, 1 yields 1/4 and 3 makes 3/4. The values 2 and 4 are not in the list so 2/4 and 4/4 will never be generated.

    This module can be used to select from a number of pre‐defined values. For instance, the SwanSong module has maze type modulation. Now you probably would not want to use all the possible maze types for the selection. For that control you could set the range from 0 to the number of maze types minus 1, and then between those values enter the indices of the ones you want to select from.

    Also I've added value indices to the popup menus for selectors to make it easier to select values for this module in case a selector is being modulated from it. These will be put between parenthesis () in the menu.
  • DelayMod - A modulatable delay Made a new delay module with better delay modulation control. A maximum length is set with the range and max length controls. The offset control sets a delay value which can be changed with the attenuated modulation input.
  • Made a stereo version of the TiltFilter module, TiltFilterStereo.
  • Added an extra input attenuator on the FreqShifter module to allow for more precise control in the low frequency region.
  • Added a range selector to the Mux and Demux modules. When for example it is set to four a 'standard' input swing of zero to one will run trough four steps only instead of trough all steps. So basically it is an attenuator on the selection signal.
  • Added a non-zero option to the Quantizer module. When it is set while the 'ceil' mode is active the output will never become zero, preventing an LFO driven from it (trough it's speed input) to stall. This option is only active in the 'ceil' mode.
  • Added x-y, y-x and x+y functions to the dyadic module.
  • Added a speed input to the RandomWalkLfo. Also made the RandomWalkLfo start at a random location after a reset occurred.
  • Added linear (lm) and exponential FM (fm) to the MultiSine module for each of the sines. These do not have attenuators and operate full scale always.
  • Added mode modulation to the ChebGen module.
  • Optimized the Fixed‐ and Prime‐Div modules a bit.
  • Added scale modulation to the SeqRandom, ProbSequencer and ScaleQuantizer modules.
  • Added a type III phase detector for the PhaseDetect module. It just multiplies the two incoming signals (double balanced detector).
  • Added linear FM to the MoogFilter, also made all FM audio rate instead of control rate.
  • Made an 'auto ready' (auto rdy) mode on the LfoTrig nd SquareLfoTrig modules to allow them to 'self‐trigger' (with a link from the rdy output to the trig input). The default mode (wait rdy) is to only activate the rdy output mode when the LFO cycle executed once, which is compatible with the old time behaviour. With 'auto ready' active and the rdy–trig link present the modules will behave like a regular LFO, exceot that the cycly count is in 'half cycles'. for instance one can make a triangle LFO which starts low goes up, low again and ends up, so it will make a quick jump to low befor the cycle restarts (a triangle with an occasional (depending on the count setting, which is modulatable) saw shape inbetween). Or a delay could be patched between the rdy out and trig in … all kinds of patterns are possible that way.
  • Changed the displayed values for FM modulation attenuators to reflect the number of semitones of modulation to occur for an input signal swing of zero to one. I.e. when set to a value of 12.0 an input signal of 1.0 will up the frequency by one octave. Also added note names (scientific i.e C4 for middle C) to be displayed in the popup hint window for frequency control knobs. Also I've made a global switch to select note names or frequencies to be displayed in frequency displays (in the Settings Screen F3)

maze tester program
The SwanTester program, for testing the contents of mazes.4th

in version 2017.7.31.0

  • Consider this release to be a beta version. I've changed quite a lot of internal stuff and have added some half finished new features. But it's about time for a new release, and some bugs were fixed … at least.
  • Error in Divider module, in the pulse mode it would flash the output too often. Fixed now for the next release.
  • There was an issue with inserting and deleting 'non-active' modules, like blind panels and the notes module. Such an action would cause the modules in the editor patch and the (compiled) synth patch to get out of sync, resulting in the lights not being updated (and possibly worse). Fixed this to always resync when modules are being added or deleted even when no structural differences between the old and new compiled patch are present.
  • Pasting text into a display editor (like in the notes module) did not work properly, as windows on double click on a static text control will fuck the clipboard. I've changed the way to call up the editor, must use Ctrl+Left Click now instead of a Double Click. It is also possible to focus the display with a Left Click and then use Enter. Will need to update some help text too … k … diddat.
  • On display editing EndStateChange was not always executed when editing ended, resulting in the patch no longer being updated correctly on wire edits. Also resulting in strange behaviour on undo and redo operations. Fixed this. Also there was a second mechanism locking undo/redo without performing a recompile at end, possibly resulting in patches no longer being compiled. Removed this mechanism entirely.
  • Added a speed input to the RandSig module. This is a linear FM input, but for the RandSig module the input value will be clipped to a range [0.0, 1.0] (where a speed of zero will stop the output from changing and a value of 1.0 will make it run twice as fast as it would with an unconnected speed input. So it is not trough‐zero for this mdodule.
  • Made the LifeSeq module rate smart, so it can run at audio rates now.
  • Sped up the AD and DA conversions as used in the DAC, ADC and Gate modules a bit by using lookup tables for bit shifts. This also fixed some levels, like the DAC would output twice as much as it should have. This will change existing patches making use of the DAC or ADC. It also changes patches using Gate modules with a bitcount other than one.
  • Changed some things in the internal working of the code, handling of controls, the way inputs and outputs are being specified, some control flow trough the program. This may result in some stuff not working anymore, sorry about that. I will fix it when I notice it … but having almost 250 mdule types now and various ways different modules can interact with the patch I may have missed some things in testing.
  • Added a manual compilation mode to the program. When it is on patch changes will not result in recompilation, instead they have to be done manually. When this mode is on you can make changes to the patch without the output going silent, then when done a manual compile (or leaving manual compilation mode) will effectuate all changes at once. The keyboard shortcust for this are Ctrl+F12 to toggle the mode and F12 for manual compilation. The help desk will get cross with me for this one … but, there is some visual feedback on this in the form of a flashing 'manual compilation' text in the top pane and also it is made visible in the Action menu. When there are any uncompiled changes the 'manual compilatin' will flash yellow, and white otherwise. At program startup the feature will always be switched off (it is not saved in the ini flle). Knob changes will still change the patch when manual compilation is on ‐ it only affects rewiring and module insertions / deletions, but this includes loading a new patch or performing any undo / redo operations.

    Anyway, thought this might be useful for live patching, we'll see about that. The work flow would be to hit Ctrl+F12 to turn the mode on, make some changes, then hit Ctrl+F12 again to compile the patch and hear the changes.

    Actually this is pretty weird on structural changes, it may cause some unexpected behaviour. Still, to do a bunch of knob edits, and have them kick in at the same chosen moment has been useful for me.
  • I've changed the default behaviour for modules and controls to be enabled for randomization. Randomization used to be all enabled by default, it's now all disabled by default. I've also changed the feedback on this, screen items enabled for randomization are now marked as being special, this used to be the other way around. (Gabe you were right about this from the beginning, took me some time to see it, thanks :-))
  • hat on knob I've added some control over the randomization range. It is now possible to set a minimum and a maximum value for randomization on knobs. This can be set by changing the knob value with Ctrl or Shift being held down wile changing the value (either trough the mouse, the mouse wheel, the keyboard or by clicking the up / down arrows under the knob). The range, when not maximal, will be indicated by an arc being painted on the knob's edge (welp … it doesn't look too pretty right now, but it works) and the selected range is also visible in the hint popup (when simple hints are not enabled). Ok, not the best image, but it's the blue hat on the topmost knob … so here is another one, blue hat, red hat the hat can be red too, meaning the maximum is less than the minimum, giving inverse response (not that such matters much for random signals). It is still possible to navigate the knob outside the set range manually. I did not implement this on selectors … as of yet … As I'm not sure how to give visual feedback on it, and also there is an issue with some of the selectors having dashes in their value list … separators … those are a bit of a PITA. I did implement it for the simple knobs not having a knob at all but jsut the up / down arrows. Here the results will be visible in the popup hint only.
  • MultiSine - A multiple sine oscillator Made a multi‐sine oscillator, which generates six sines with individually settable amplitudes and frequencies individually settable relative to the main tuning. The amplitudes can be modulated by an external signal. The chain input is summed with the oscillators into the output. There are mutes for each sine individually and on the resulting output as well. The sync input when going active resets the phase to zero for all the oscillators. The main tuning has exponential FM modulation and a separate frequency fine tuning. Id did not find room to include PM, but each oscillator has a separate AM modulation input.
  • TextWriter - A text writer Made a text writer module which can be used to write text into a file. I use this to couple a radio stream title to a patch, such that when I change the patch the stream title will be updated automatically. It can hold multiple lines of text, and sending out the next text is controlled from a trigger input. When the module does not get triggered it will statically output the first text line. The text file will only be updated when a new line of text gets selected. This happens at patch load time, patch reset or when a trigger comes in and there is more than one line of text. When the file does not exist it will be created, and when such fails nothing bad should happen.
  • CuClipStereo - A stereo version of the cubis clipper Made a stereo version of the cubic clipper. It treats both channels independently but with the same parameters, as if there are two clippers set up with the same alpha and hysteresis values.
  • AutomationStep - An automation stepper This module will step trough recorded automation snapshots, this can be complete snapshots or recorded single value changes. The control can loop once it reaches the end, and it can be made to play in two directions.
  • I've added value history on knobs, modules and the patch as a whole. This with the possebility to undo an edit without a recompilation being needed. It is also possible to make selective undos on the patch by selecting a bunch of individual items in the list. This works on the patch level only, for the control and module undo only one item can be selected from a popup menu. See the images below.

    With this I've also split the undo history up into two separate histories. A history for structural changes (those can be undone and redone with Ctrl+Z and Ctrl+Y) and this new 'value history', which can no longer be undone/redone with Ctrl+Z and Ctrl+Y. The control history, on undo, will not silence the patch while a structural undo / redo does need patch recompilation, which will stop audio briefly.

    Also this causes automated changes (like randomization, morphing etc.) on the patch to not be recorded in an undo history anymore. Which also causes live morphing to no longer mess up the undo history, it is just not being recorded anymore. (but you can still make snapshots for the automation recorder.)

    Still working on a method to let cable changes not cause silence, as those would not really be needed (a cable change results in some pointers being changed only).
  • mini event recorder And while at it, I've also made an event recorder. In its current state it can only be used to play back snapshots, timed playback is not working yet. With the new AutomationStep module described above this can be controlled. I'm working on more features, and also working on keeping things consistent when modules are added or removed from the patch (it's all a bit messy still, trying ideas mostly). See image below, and the mini version of it on the left.

    There is no automatic Save and Load currently, but the automation control screen has a load and a save button. Automation is saved into a separate file with the same name the patch jas file has and an .automation extension, on load it will be checked if it matches the patch it was generated on.
  • Another thing I'm working on is an abstraction editor. It is possible to make details of a patch public, the abstraction editor will pick up all the publics and generate a module from that with the publics at odd positions, but stuff can be edited. This is even more just in the 'gathering ideas' phase. Anyway, I'll not disable it for a release even whn it is not very useful currently. See image below.

    There is no automatic load and save for abstractions, but there is a Load and a Save button in the abstraction editor. Abstractions are saved in a file with the same name as the patch it was generated from using .abstract for the file extension. On load it will be checked if the abstraction matches the currently loaded patch.
  • Added a 'unique ID' (GUID) to patches to keep track of mappings between patches, automation and abstractions. These should not be to easily tracable to the computer which generated them … when I can believe the µSoft docs on this. Anyways, you can always strip them out, the patch will still load.

    The GUID will not change during the lifetime of a patch, not even when structural changes are being made. This means that the sync between patches, automation and abstraction may still get fukt. At least its not possible to load abstractions and automations on a patch it was never based upon.

    I'm trying to make it so that when a patch is being change structurally and an abstraction or automation is loaded for it that these will be updated in a sensible manner. (And eventually such would mean automatic save / load will be needed on abstraction and automation files (or tht they get stored into the patch itself).) Anyways … for now, you will loose somme work probably while working with the new features.

control history
Control history
Single items can be reached (and be undone) trough the control popup menu.

module history
Module history
Single items can be reached (and be undone) trough the module popup menu.

patch history
Patch history
Multiple items may be selected to set them to the value present in the 'Prev. value' column.

snapshot recorder
Snapshot recorder
The knob on the highlighted module marked in green is the currently selected control, the one to which the graph applies. In the patch mod 1 is the player, allowing for snapshots to be played in a clocked manner (not respecting the time they were made on). So his acts as a sequencer, basically. A click on the send button will send a whole column of values back into the editor. The Clear button is destructive, it removes all recorded events. Points in the graph can be moved around, when moved in value only the value will change for that step, when moved in time a new time steop will be added. I'm working on more functionality.

abstraction editor
Abstraction editor
Items marked in black are made public, the green item is the currently selected on in the editor for which properties can be changed. This is a toy for now to gather ideas.

in version 2017.5.21.0

  • There is an issue with the Seq16 module in that it will sometimes not run due to the number of steps being seen as zero, I've fixed this. Meanwhile a workaround is to press F7 or F12 to make the sequencer run again.
  • There was still a race condition in the PulseSync module, solved now. A negative edge on the sync input would clear the internal state, but the incoming pulse might not have been processed yet (in case of a long sync pulse time). Made a counter now which will clear the internal state and the output after a fixed number of cycles, and in case the pulse input had gone active again within that time it will just be armed anew.
  • Changed the module order on the Control tab to have all scaling modules grouped on the left side.
  • Upped the maximum count values for the triggerable oscillators and LFOs. This will change existing patches using these modules.
  • Added Hold mode on EnvAHD module. When on it prevents the module from going into Release as long as the trig input is still active. When off the module works as it always did.
  • Added an active output to the LfoTrig modules. This differs from the inverse of the ready output in that ready will never be active before the first cycle ran (and the module will not run then yet when it saw no trigger signal).
  • Added some swell control to the EnvAHD module. Swell when active will cause a rise during the hold phase of the envelope. The amount of the effect can be preset and modulated, and the shape can be selected. The time for the swell is the current hold time. The envelope graph more or less shows the effect of this new control.

    Added swell to the EnvADSR module as well. It works a bit different here, the swell time is taken from the release time instead of the decay time (as there is no hold time to be set). Also setting a large amount of swell will reduce the attack level by up to one third.

    With swell set to zero the modules behave as they did before. For shape impressions see the image below.
  • Added a freq (unattenuated FM) input to the HrastOsc, also added shape and morph modulation on it.
  • I've changed the sensitivity of all speed inputs on LFOs and oscillators. They will run twice as fast as normal now with an input signal of 1. A zero input signal will make them stop, and with negative values they will run backwards. Of course the only wave shape changing on that will be the saw wave. This will change the behavior of some existing patches.
  • The phase modulation on oscillators and LFOs was changed to something more correct (for large phase modulation values), turned out to be a tad cheaper as well.
  • For the following modules I've changed the range of the slew control to make it more useful: TypeFlip, SeqChord, Slew and SeqRandVal. This will change existing patches making use of the slew control on these modules, however when slew was off on them it will still be off for the new control range. Also it is still possible to fully freeze changes with the control turned hard right.
  • Added 'function modulation' to the Gate module. The blue input when going from zero to one will go trough the eight selectable logic functions (it is being used as an offset (modulo 8) on the value from the Gate type selector).
  • Renamed the Pulser module into Wavolver ‐ as it was really that … and then made it work properly. The renaming will break existing patches using this module, the module will still be loaded but all connections to it will be lost. But then again, the name was plainly wrong, and it did not function properly either. The actual pulser thing can be done now with the triggered oscillators, I've added pulse count modulation to those. These are all variations on VOSIM of course.
  • quantizer steps Added a new display mode to the Quantizer module. It used to show fractions of notes, it can now show fractions too. Not that this changes anything on it's workings, but with the mode set to Fractions it is easier to understand how it works for linear control of (low frequency) oscillators. For instance (see illustration), when the fraction is 1/4 and the rounding type set to 'round' and the output is used for speed control of an LFO the LFO will run at n/4 of it's set speed (for n = 0 to 4 assuming an input ranges of 0 to 1, and assuming the linear frequency control is being used (called speed in most places)). I've added the same option for the built-in quantizer in the SeqRandVal module.
    I've added different rounding types for the internal calculation. The module did use the Round method before, but it can now also use Flooring and Ceiling. The default still being Rounding. The illustration shows the quantizer set to 1/4 with from top to bottom the input signal, the floored quantized value, the rounded one and the one using ceiling. This option has not been added for the SeqRandVal module, that one will always round.
  • Changed the Song module to have active 'end' and 'silence' outputs at patch startup and after reset (both global and module specific), they used to be inactive then. This makes it easier to use a PulseSync module on the 'end' and 'silence' outputs. This may break some patches that are making use of these outputs, but not likely so.
  • Shaper - A signal shaper Added a signal shaping module, it can transform a linear input signal into an envelope shape type output signal with inversions and signal types being applied. The module is rate smart, so it can be used for audio signals as well (but there will be some aliasing). For shape impressions see the graph below.
  • PropScaler - A proportional scaler Added yet another scaling module, the PropScaler. This one has a modulatable parameter p which controls the in to out transfer as:
    out = in * ( p - 1) + p.
    This replaces a set of four modules that would otherwise be needed to make the same functionality. Effectively p sets a lower limit on the output value and the input range is proportionally distributed over the remaining output range.
  • ModOsc - An oscillator with more modulation control Added a new sine oscillator with more modulation control than the other oscillators have. It has amplitude modulation, phase modulation, linear FM modulation (trough zero), exponential FM modulation and in addition the frequency fine tune can be modulated trough the ct input. The sync input is a hard sync. when it goes active the internal Phase accumulator is reset to zero.
  • AnalogXor - An analog XOR module This is after an idea by Ian Fritz. The analog xor makes it's output active only when the sum of the input signals is over the set set Threshold value, but below 0.5. The threshold can be set from -1 to +0.5, and it can be modulated trough the T mod input.
envelope shape impressions
Envelope shape impressions

shaper shapes example
Shaper shape impessions

in version 2017.4.22.0

  • Moogfilter could produce denormals - added some guards there. Also optimized the filter a bit (20% off from the execution time), but it still uses an awful lot of cycles ‐ more than a reverb does ‐ I don't really understand why that is.
  • Compressor could produce denormals - added some guards there. Pluck module idem.
  • Graph Image for S shaped attack on the ADSR envelope module was wrong, fixed it.
  • Made the S attack and decay modes working on the Seq16 module, they acted like exp by mistake.
  • Added code for trying to get some better idea as to why PortAudio initialization failed. It will report failures to the logs.
  • Added an off-beat output to the EuclideanRhythm module, it is active whenever the regular output is not (and the clock is active). Basically it runs the reverse pattern of the regular output.
  • Added an invert input to the Seq16 and the Sequencer modules. In invert mode the sequence is put upside down.
  • Added inputs to the Switches4 module. When these are not connected it will behave as it used to. And when they are connected they will be switched to the outputs.
  • Added range modulation to NoteQuantizer, ScaleQuantizer and ModQuantizer modules.
  • Added tanh( x) function to the Monadic module.
  • Added chain inputs to the TransInv module, these are just added to the calculated output signal.
  • Made the pulse delay module rate smart ‐ however ‐ the shown times are eight times as short when the module runs at audio rates (this is being indicated in the displays). Also made the MultiCompare module rate smart, so that now all the logic modules can switch to audio rate computation.
  • Added some values to the MConst module to make it usable for controlling note intervals. uni (0), mi 2nd (1), 2nd (2), mi 3rd (3), ma 3rd (4), 4th (5), dim 5th (6), 5th (7), mi 6th (8), ma 6th (9), mi 7th (10), ma 7th (11) and octave (12). These values are TET based and are fixed, even when the main tuning is changed.
  • Added a sent output to the MIDI CC output module to allow for easier sequence control.
  • Added a clear input to the Delay module, when it goes from inactive to active it sets all the delay memory to zero. This is glitchy, as it was intended to be.
  • Added input attenuation controls for the Formant and Formant2 modules.
  • Added a speed input for Osc, Square, MultiOsc, OscTrig and Squaretrig oscillators. This basically is linear thru zero frequency modulation. When speed is set to zero these oscillators will stop and they can be used as lookup tables by controlling them from the pm input. And while at it … also added speed controls for Lfo, SquareLfo, LfoTrig and SquareLfoTrig modules.
  • Changed the maximum acceptable input level for the GVerb module to 100, in the original code this was 1e5 or so and had that lowered to 10 before ‐ but it could cause distortions that way … so upped it a bit. These are silly levels, but this can happen when the input level is high and the output levels are set low to compensate for that. Which would be silly to do probably, but I needed some more forgiveness there.
  • Added a 'hold' mode for the EnvAR, EnvARRetrig and EnvConrol modules, when active they will not enter the release phase as long as the trig input is still active. Also removed a possible click from these modules ( on the transition from Attack to Release or Hold mode) and removed some needless calculations … like subtracting Ln( 1).
  • Added mode selectors for the FixedDiv and PrimeDiv modules, these can be set to either Square or Pulse. In Square mode the outputs will all have a 50% duty cycle and in pulse mode they wil be active for one positive input clock time.
  • Added a reversed mode for the arpeggiator, and added a reverse input for playing the arpeggio backwards. The reversed mode plays the notes in reversed order of reception i.e. last note first. Also added a transparent mode, when the Transparent control is active no arpeggiator actions takes place but instead the last sampled input value is being output when the output clock goes active (making the module behave like a sort of a sample and hold module (except that it has two sample clocks then).
  • Added a trans(parent) input on the Poetry module. When it is active no poetry generation takes place but instead the last sampled input value is being output when the output clock goes active (making the module behave like a sort of a sample and hold module (except that it has two sample clocks then).
  • Added count modulation inputs for LfoTrig and SquareLfoTrig modules.
  • Added a level modulation input for the Quantize module.
  • Made the control decimation programmable, it can be set from the Settings Screen F3. The default value is 8, what it always had been, but it can be lower or higher now. Higher values will mean that less processor resources are being used. Changing the value however also means that some modules will run faster or slower, this affects some of the blue filter modules i.e. the slew times may change etc. It is of no concern for the red (audio) filters though.
  • Seq16 - Canon outputs on seq16 Working on some MANIAC features …
    I've dded cross fade modulation to the Seq16 module and also added a random input. The random input will set all the faders to random positions. Added three 'canon' outputs, these are shifted by four steps for each one. So when the first output outputs step1 the 2nd out sends step 5, etc. This way the sequencer can be used as a 2 x 8, 3 x 6, 4 x 4, … sequencer, but it is also possible for instance to set like 12 steps and use output 1 and 3 and then they will have eight sliders overlapped and four unique ones for for themselves. The xfade works on all four outputs, but there is still just one chain input which is being added to all four outputs. Added a 'hold' input, which when active will hold the last sequencer output value and it will also block the chain outputs from being updated, but it keeps the sequencer running. Then added skip inputs for each step, when a skip input is active that step will not be used (making the sequence a step shorter). Added a clockskip input too, when it is active the sequencer will freeze at its current step. This is different from the Active input in that the Active input outputs no step values but passes on the chain outputs only. When a clock is being skipped the current step and output values will be he held and the chain inputs are no longer sampled. Then I went on and made 16 step outputs, going active when the step is active and the incoming clock is high or the trigger mode is set to (G)ate. Oh, and also added a TimeWarp (tw) output, which can be used to control the speed of the driving clock, it is meant to drive the speed input of an LFO. The idea is that when steps are being skipped the sequence length can be kept the same when using the TimeWarp output in this manner.

    Getting closer to the M.A.N.I.A.C.
  • LUT - LUT changes Added the 'canon' outputs on the LUT module as well. Added a 'steps' control as well to map a zero to one signal range on the set number of steps, step count can also be modulated. Then added a random input for doing fader shaking too. With a negative step count (which can be set trough the steps modulation input) the unit will run 'backwards' ‐ that is ‐ for larger selection values it will move to a lower step value. Note that with fewer steps and a ramp on the input there will be less steps in the same time, so when used as a sequencer the sequence will run slower then. Added 16 step outputs here too, there is no clock or active input on this module, so the step outs are active for the whole time the step is active.
  • DCBlock - A DC blocker Added a DC blocking module with a -3dB point that can be set from approximately 20 ~ 40 Hz to 400 ~ 800 Hz in audio rate (red, depending on sample rate) mode and from 2.5 ~ 5 Hz to 50 ~ 100 Hz in control rate (blue, depending on sample rate) mode. The further the knob is turned right the higher the cutoff frequency will be. DC will always be totally blocked no matter what value the cutoff is set to. Feedback delay lines (and there are a couple of other modules that do not like DC very much) can lock up when there is DC present in the loop, this module can be used to get rid of the DC, probably best before the loop and not inside it.
  • MidiPCOut - A MIDI Program Change output module Added a MIDI Program Change Output module, also featuring a sent output for easy command sequencing. It will send out a a program change message when the gate goes active or when the program is manually changed. The actual program is the SUM of the values read from the prg control and the progr input. A change on the progr input will not trigger a message to be sent ‐ a gate signal is needed then.
  • MidiPNOut - A MIDI Parameter Number output module Added a MIDI Parameter Number Output module. This module can send both RPN and NRPN data and it can do so with the most significant septet only or it can send both data septets. Added the chain output to this one as well. Data will only be sent when the gate signal goes active.
  • Compressor - Compressor changes Changed the compressor looks a bit. The LED scale was not very informative (as the scale is pretty large things barely moved, and there was no feedback on actual gain either) so … removed it, but added a dB value indicator showing the current amplification.

    Also added a side chain input and output. Effectively this is a 3rd compression channel where the compression is being calculated on either the side chain channel (side mode) or on the stereo signal channel pair (norm(al) mode). So it is also possible to side-chain a mono signal from the stereo inputs.

    Then added a DC blocker on the inputs as in RMS mode DC on the inputs can do some weird stuff. The blocking can be switched between AC and DC. AC mode has a -3dB cutoff point at approximately 20 ~ 40Hz (depending on the sample rate) and DC mode does nothing, The filter will only operate in the compression calculation chain, the signal chain is not being filtered.
  • PulseSync - A Pulse sync module Added a PulseSync module. The module gets triggered by an incoming positive edge on the pulse input, which it will then hold internally. When a subsequent positive edge appears on the sync input the output will be set active. Once the pulse got processed the output and the internal state are both being cleared when a negative edge is seen on the sync input. The incoming pulse is guaranteed to never get lost.

    This module can be used to sync up a pulse event appearing at a random time to a syncing clock signal.
  • Transpose - A Transpose module Added a Transpose module. Four separate transposition amounts can be set each having an activation input. The output will be the input note value transposed over the sum of the active transpositions. Transposition range is -24 to +24 semitones.
  • SquareSineLfo - A Square and Sine LFO Added a SquareSineLfo module, it outputs a sine along with a PWM controlled square wave. I often end up clocking things with sine LFOs as sine are easy to multiply up to higher frequencies (using the ChebGen module) which is easier often than starting with a higher clock and dividing it down. Also the sine shape is more useful to do (synced) modulations with. However its not easy to change the 'pulse width' of the sine, so that is what the square PWM is for, that one is easy to make changing note lengths for driving sequencer.
  • PulseSkip - A pulse skipper Made a PulseSkip module. It will pass on input trigger signals only when the input level is larger than the compare level. Levels are computed as the sum of the preset level (as made visible in the displays) and the modulation level. Once a pulse got started will only be ended when the trig input goes inactive, so either a complete pulse is being passed on or it is being skipped.

in version 2017.3.14.0

  • Bug in DataGraph module for the splines mode, it outputs X values instead of Y values. Using Y works way better - so that is fixed now. And its not in the AudioGraph module, as that one can not use splines ‐ pwew :-)
  • Mode and range changes through selectors were not handled when controlled with the keyboard (only mouse clicks worked for that), fixed it.
  • Added an 'act' input for the EuclideanRhythm, SeqRandom, SeqRandVal, Pattern and ProbSequencer modules.
  • Added inv outputs on EnvAHD and EnvADSR modules, they output 1.0 minus the value that is on the env output.
  • EnvControl - An envelope controller Made a controller module for the DataGraph module to allow it to do envelopes. The help blurp says : A retriggerable envelope controller. The envelope will start when the trig input goes from zero, or below zero, to above zero. The output will then in the set Attack time go to the level set with the level control. When the trig input falls off the output will start getting larger again for the set Release time, till a value of 1 is reached. At every new trig start the output value is reset to 0, and the above cycle will restart. Both the Attack and Decay phase are linear, any non linearity is to be set in the controlled graph. This module is meant to control the GraphControl module, the actual envelope shape is then drawn in that module. The set level will then correspond to the vertical distance in the graph where the hold value will be.
  • SeqPattern - A pattern sequencer Made a pattern sequencer module to be used for drum patterns. When set at low speed it can also be used to control the time structure for a self playing patch.

    A full pattern is made from eight parts, where each part is composed of eight sections and each section has eight elements. This makes for a total of 512 steps, where each step controls 24 bit outputs simultaneously. The steps can be set to off, to pass the incoming clock, or to be on.

    For detail information please click on the module, or for some background information have a look at the forum thread.

    Sequences can be saved to disk and reloaded just like any module (or any group of modules) can - as a preset. Right click on the module and select load / save preset from the context. menu.

in version 2017.2.25.0

  • Range control for the pulses module was not working, fixed that.
  • Output signal type selection for the pulse delay module was not working, fixed that. Also tried to clarify the help text a bit.
  • Constant module when put into 'note' mode is off. And this seems to be wrong in more module types. Indeed it did affect the Constant, LUT and Knobs4 modules and it is fixed now. Also made it so that when 'notes' mode is selected the note controls have 128 steps now, and possibly some other number in the other modes. Also the LUT module was having an offset in the 'notes' mode, this got fixed too. These changes will affect old patches using any of these modules in 'notes' mode.
  • Made a Moog style 24 dB low pass filter. MoogFilter - A Moog
          style filter Inspiration came from a github site, the Huovilainen variation on the theme. I've found it to be a bit explosive … the volume that is, so made it to oversample a bit more and also added a saturation function (tanh) on the output, as it had a tendency to go like very loud when resonating. This is not a cheap filter CPU wise, but I think it to be a nice one with the built-in distortions. On the referenced web site there are some more variations, I may try some other and make a selector maybe for different types.
  • Made a fixed divider module. FixedDiv - A fixed divider The module has a series of outputs with fixed division rates. After reset all the outputs will be off, to be toggled each time the number of input clock periods matches the division count for that output. The output will stay high for one clock period then.
  • Made a multiple waveform oscillator. MultiOsc - A multi
          wavform oscillator This module simultaneously makes a sine-, a trianglar-, a saw- and a square-waveform. The PWM input provides linear Pulse Width Modulation (on the square output only).

in version 2017.2.19.0

  • Delaytime range on stereo looper was not working, fixed now. Also changed the start and length control modulation amount knobs to be displayed as linear (they were actually working as linear controls already but not displayed as such).
  • Some screen painting took place on the desktop's device context, changed that to happen on the editor's context only. This draws better selection rectangles and better lines (on cable drawing). This may as well solve an issue with the screen not being repainted properly (which was reported by someone using Windows 10). Also thickened up the lines a bit for better visibility.
  • Added inv outputs on EnvAR and EnvARRetrig modules, they output 1.0 minus the value that is on the env output.
  • MIDI transmit bug. The command was never sent only the data bytes … Fixed now. And of course I had forgotten to test some code …
  • Added f(x) = - x and f(x) = 1 - x functions to the Monadic module.
  • Added a a modulation depth control module ModControl - A
          modulation depth controller . The graph illustrates it's workings (where the red signal is the wanted modulation depth (mod), the green signal is the modulation (in) and the blue signal represents the resulting output). For the inputs and the output the signal type can be set, for the graph they were set as in the module image. The mod signal and the output being unipolar and the modulation (in) signal being bipolar. I've made this module primarily for AM modulation (tremolo), but it would work for vibrato as well when applied to a PM input of an oscillator.

    The internal calculation used is : out = mod * ( in - 1) + 1, so that when mod = 0 the output will be 1 and when mod = 1 the output will be a copy of the in signal. This is being calculated on signals assumed to be positive only (unipolar), the input output type selectors are to be used to ensure such scaling. modulation depth controller

in version 2017.1.29.0

  • When windows screen magnification is set to something else than 100% everything on screen gets messed up. Turned off screen scaling, which paradoxically results in better scaling - I guess the scaling property on forms is a promise to windows ... anyways, windows will now scale all stuff properly - or so it seems.
  • Bug in LifeSeq module, the chain input does not work ‐ fixed now.
  • Obscure bug in the wave file reader code, it would read more samples than present in the audio file which would cause glitches on playback. Fixed now.
  • Some of the 6 dB filters (the high pass parts) could produce denormals, fixed that.
  • Bug in multiplier module where the leftmost input would not work due to having a wrong name. Fixed that, but all patches using that input were not working properly and on reload will not restore the connection. When needed this can be fixed manually. Open the patch in a text editor, search for all occurences of the text 'multiplier_in47' and replace all of them by 'multiplier_in7', the patch would then load again as intended.
  • Bug on pasting modules. It looks like when a selection larger than what is present in the current patch can not be pasted. This has to do with an internal naming conflict for modules. This issue must have been present for years I think, looking into it now. Is fixed now, it made the code somewhat simpler too :-)
  • Added a reverse input to the LifeSeq module, when active it plays from right to left. Also added stops to the module. When one stop is set it will play from the first column up to the row where the stop is set and it will then jump back. When two stops are set it will start in the column after the leftmost and it ends in the column just before the rightmost. When the reverse input is active this gets reversed. When no stops are selected the full range will be used. On reset the cursor will jump to the column after the leftmost stop, unless only one stop is set ‐ in that case it will go to the first column. This also gets reversed when reverse mode is active. I thinks the stops to be interesting mainly for the sequencer mode.
  • Changed MIDI NoteOn handling a bit. When a NoteOn with velocity 0 is received it gets translated into a NoteOff event. The velocity for the generated NoteOff was set to zero, it is now set to 64 instead. Changed that for the MIDI file player module too.

    Implemented running status for the MIDI transmitter, this was already present for the receiver.

    Updated the MIDI decoder and encoder to be able to handle RPN and NRPN data, so could make modules handling those MIDI messages now. Implemented a mode for this. When 7 bits mode is on the callback will be called when the MSB comes in, in 14 bit mode the callback will be delayed until the LSB comes in. When MSB and LSB get swapped by the sender it will still work, provided 7 bit mode is selected, as in 7 bit mode LSB reception will not trigger the callback (and the internal value gets updated anyway on both MSB and LSB reception.

    Data increment and decrement are implemented as well, in 7 bit mode they will change with steps of size 128 and in 14 bit mode with steps of size 1. Increments and decrements are clipped to the range [0 .. 16383] (which may get interpreted as a range [-8192 .. 8191] depending on the actual receiver), no wrapping takes place ‐ could make a mode for that too though I guess.

    All this is in preparation for MPE (Multidimensional Polyphonic Expression) … going to be some messy fun that for what's basically a mono synth … sorry paraphonic :-)

    But first MIDI will need little more attention.
  • [partially obsolete] For PortAudio I've changed the way buffering is handled. It is now possible to set buffer size of zero, whech means that PortAudio decides on it. This works for ASIO as well.

    [As of 2019-04-10 legacy audio mode was completely removed.]

    For legacy mode this is not possible, a 4096 byte buffer will be used in legacy mode when 0 was set. I've noticed that the WASAPI interface gives me best results for latency, but I've also noticed that I'll have to shave off some of the peak load for some of the modules to be able to use that for larger patches. I've added a buffersize display under the CPU load display to be able to see what gets actually being used (it shows the number of samples delivered and requested by the PortAudio callback). Setting the buffer size to zero may cause the VU meters of the main window to be updated a tad irregular, but didn't actually really see that. Also, in the Debug Screen F5 I've added latency indicators, they show what is being reported by PortAudio.
  • Processing for the LifeSeq module is spread a bit better over time now. After a change request was seen a column counter is set up which gets adjusted on every control rate tick. On each tick only one column of the automaton gets updated. As a consequence the updates should not occur any faster than once every 32 control rate ticks (SampleRate / ( 8 * 32) Hz). Also the display will now get updated only when there was a change.
  • Made it so that all MIDI sends from a patch on a channel > 16 are sent back into the patch itself (and the channel is decremented by 16 then). This makes it possible for a patch to send MIDI data to itself by allowing it to send on a channel > 16. For the MIDI send modules these channels can be selected as ic 1 to ic 16 (ic standing for Internal Channel). The MidiNoteOut and MidiCCOut modules now allow for such channels to be selected, so a patch can now send notes and CC messages to itself. Such MIDI messages will be handled internally in the synth patch and will not be visible outside it (like in the user interface, or in the outgoing MIDI stream).
  • Two new modules, a Phasor Phasor - A Phasor and a painted waveform thingie, the AudioGraph module

    The Phasor was created to control the AudioGraph, but it can also do phase control for oscillators.

    The AudioGraph is better suitable than the DataGraph module for audio rates as it AudioGraph - A painted waveform module internally uses Differentiated Parabolic Waves to reduce the aliasing a bit. I've added an auto scaling feature which after every data alteration rescales the graph to use the full Y value range. This feature can be turned on or off.

    Also added an input to randomize the graph, randomization will occur when the random input goes from zero or lower to something greater than zero. The actual momentary value at that stage is used to control the amount of random to be applied. Small amounts (near zero) of random cause the graph to be changed just a bit, a value of one would create a totally uncorrelated new graph. Unfortunately the rnd input acts sluggish … maybe something to fix later on.
  • Added a tilt filter from the music dsp site. TiltFilter - A tilt filter A center frequency can be set for it and a tilt factor for the frequency response line. With tilt in the mid position there will be no filter action, turn it up for more highs or down for more lows in the output signal. The center frequency is the point the response line rotates around. The maximum tilt is ± 6dB / Octave.
  • Song - Song module Added a txt end output to the Song module, it will fire when all phonemes are spoken. It will not fire initially so it can not be used to make the module self looping. However, the module does have a loop mode for that purpose. I've added it to be able to only start the module when it was not already running (with an RS flip-flop added).
  • Demux - Demux module Added hold mode to the Demux module. When active XFade will no longer work and outputs will keep their value when they get muxed out (integrated sample and hold). The new button toggles between cross fade and hold modes.
  • RandomWalkLfo - RandomWalkLfo module Added a sync output to the RandomWalkLfo module. The sync output goes active when the output values change and it goes inactive halfway the LFO period. This so I can get triggers at the LFO rate. Also added an output smoothing mode to this module. When smoothing is off a stepped wave is produced, when it is on the wave glides from old to new values. And also added a distance modulation input.
  • Value - Value module Added a maximum value display to the Value module, it will display the maximum of the absolute value seen. A reset button was added too to be able to reset the maximum to zero. Also a patch reset will set the maximum value to zero.
  • Changed ini file loading a bit, at first Wren will try to load an inifile based on the name of the actual executable file name. When such does not succeed it will try to read a file 'wren.ini' from the same folder the executable is in. This assumes Wren originally will be called 'wren.exe', but makes it possible to have a copy of the executable under a different name which will then try to read the original settings (but they will be saved into an ini file named after the actual executable fiel name). Anyway, this should make it a bit easier to have two (differently named) Wren executables in the same folder, and to have the new one to initially inherit the settings of the default one (they can be set to differ later on). The looks will always be shared.

in version 2016.10.23.0

  • Oops ... a bug in the AM modulator causing an addressing error, fixed now.
  • I've changed the implementation for the intdif module a bit. For the integration function the output value is divided now by the execution rate of the module. This can be scaled with the gain control slider, but it means the output will be way lower than it used to be. Likewise for the differentiation function the output value is multiplied by the execution rate, and this is also scaled with the gain slider. This results in way more output signal for the differentiator. Also the output values for both integrator and differentiator are clipped to a range [-10 .. 10] (this used to be the case for the integrator only). The execution rate depends on the set sample rate and it can be either control rate or audio rate depending on the rate of the input signals.
  • Markov - A Markov chain module Trying my hands on some Markov stuff. Not sure if I can get the learning mode fast enough for real time use, playback should not be a problem.

    This is a first order implementation.

    The internal state consists of a number of nodes each holding some value (for which a maximum must be set with the max size control), a State variable holding the current node index (which is not under direct user control) and a matrix of transition chances (which is not under direct user control).

    When the learn input goes active the current input value is looked up in the nodes, and when found the transition probability from the previous input value to this new one will be increased with the current strength value (which can be negative). When the new value was not found it will first be appended to the node list. When the node list becomes full and the mode is set to 'once' an overflow condition occurs and the new transition will not be learned (also the Ovfl light will go on then). When the mode is set to 'cont' no overflows will occur but the oldest transitions will be discarded instead.

    When the 'new output' input goes active the current State variable will move to a new one, this is a random process controlled by the transition chance matrix.

    The state of the module can be saved to and loaded from a file (must still implement some user interface for that), so … training could be done in non-real time mode when the need arises. Anyways .. let's test things first ‐ actually it does not seem to perform so bad, great :-) It will depends on the input material, when there are many different values things may be worse, but for discrete events (like note values) it seems all fine.

    Now it needs to be made a bit leaky … as currently when the input patterns change it will take longer and longer before those new patterns will be learned. Although setting random strength values seems to help here ‐ just like setting not too many nodes and using 'cont' mode.

    Now working on some code to do do the Markov thing a bit more efficient so I can hopefully implement a second order implementation which is fast enough for real-time learning.

    Ok, that seems to work. It also seems to be not too hard to generalize it a bit to arbitrary orders. I've implemented something, but found no time yet the check the workings or the performance.

    After a little break and some bug fixes … arbitrary order seems to basically work, it needs more testing though.
  • Filter6dB - Another 6 dB/ Oct flter Made a variation of he Average filter with direct frequency control (instead of just exposing alpha). The set frequency references the - 3dB point. Filter falloff is 6 dB / Octave, just as for the Average filter. The filter should work on control and audio rate signals (Rate Smart).

    Filter6dBBP - Another 6 dB/ Oct flter Made a bandpass variation on this and then made a stereo version of that one too. I've used this one on the final output of a patch to trim off excessive lows and highs a bit.

    Filter6dBBPS - Another 6 dB/ Oct flter When in control rate mode the frequencies are off by the control rate decimation factor (currently 8), the displayed value being too high. I should fix that by displaying the lower frequencies, but as of yet there is no proper mechanism for that.
  • Added a new tab for generators (gen) and moved some of the 'sequencers' there. This tab is meant to hold modules to be primarily used for generative music. So state machines, song generators, cellular automata etc. Moved some modules from the control tab to the new tab as well.
  • CellAut - A simple cellular automaton Automata … well … just one automaton for now, but will likely make a couple more based on the same underlying engine. This one is a rhythm generator only.

    This module implements an 'elementary cellular automaton'. Each cell can have a value of either zero or one. Three cells are evaluated according to the set rule and this will yield a new value for a next generation cell. The rule number [0 .. 255] is being interpreted as a bit pattern which is indexed by the three bit pattern generated from the three evaluated cells. This is all according to Wolfram's theory about elementary cellular automata. The start state of the automaton consists of one single cell having a value of one.

    With the steps parameter you can set the number generations to be calculated, this results in a bit string. On every step a next bit will be sent to the output and when the end of the string is reached the sequence will wrap back to the beginning.

    The Faults parameter sets the average number of cell faults generated for each new cell calculated. The set number is divided by 10,000.

    The total length of the generated pattern increases with two on each new evaluated step, which results in length = 2 * steps + 1, which is odd always. The reset input can be used to wrap back sooner.

    The blue output has a weighted sum of the last three bits ( Bit[ anIndex] + ( Bit[ anIndex - 1] shl 1) + ( Bit[ anIndex - 2] shl 2)) / 8.0. The dir input when active reverses the play direction.

    Some rules will not generate any output at all (like rule 0 or 255), some will generate simple repeating patterns and others will be almost random. For some rules the steps setting may not change the sequence much, for others a next step may differ wildly from the previous one.

    For some ideas about possibly interesting rules have a look at my rules page. At some stage I may build some of the visuals into Wren , but not at this stage. That page, at the very end, also shows an implementation of the algorithm being used.
  • LifeSeq - A 2d cellular automaton And another cellular automaton based module. This one uses Conway's game of life. the current help text says (subject to change though):

    A Life based sequencer. Based on Conway's game of Life, but there are some extra modes selectable from the mode selector. The step input moves the cursor, which will put the cell values from the current column on the green outputs. The change input triggers a new generation of live cells, according to the currently selected rule. The blue sum output has the column sum of the cells under the cursor, this can be a binary sum or a linear one. The grid can be set to be wrapped or unwrapped. In wrapped mode the top connects to the bottom and the left side to the right. The fault rate parameter determines the amount of faults made in applying the evolution rule. When the number of cells drops below the low count the grid will be filed with random values, the chance of a cell becoming alive is set with the rnd amt parameter. The rnd button will fill the grid with a random pattern, obeying the rnd amt setting. The clr button will clear the grid, this usually will then immediatly set random pattern as the live cell count drops below the minimum. It is possible to draw on the grid, a single click will toggle the cell state, with shift cells can be turned on and using ctrl instead will turn cells off.

    Using a right click on the grid the current state can be saved to or loaded from a file.

    This a a pretty big module, and 32 rows seems a bit much maybe, but I've found the game of life to be more interesting on larger grids. The current 32 by 32 size seemed a minimum for interesting patterns to occur. And at the same time 32 logic outputs seems like overkill as well, for the sum output it's a nice amount though (2.5 octaves in the note modes).

    Made an inhibit control on the change input to be able to stop rule evaluation, and also made a 'Freeze' mode (in addition to the various ;ife modes) in which the current pattern will not change ‐ this allows for painting sequences.

    Now if only I could get the module to load itself from a patch file … it would then double as a 32 x 32 (event) sequencer (the sum output can be set to make note values though) … it also reinitializes on every module insertion or deletion … which it should not do. But otherwise it seems to work well. Ok, the save and load stuff works too now, but the mode has to be set to 'Freeze' for this to work properly (or else the internal Life machine will have it's own ideas about the pattern).

    The new grid control thingie could be nice for other modules as well :-)
  • When Wren is closed the current patch will be saved in the application's home directory (where wren.ex resides) as '__l__a__t__e__s__t__.wren'. This file can be reloaded from the file menu trough the 'Load last patch' item. For just in case … This is not saved in the most recently used patch list (unless you manually open it; it will not be opened automatically on Wren startup).

in version 2016.10.2.0

  • Added the Markov module, but it has not been fully tested yet, see remarks in the 'working on' section above. Also I did not implement the code for saving and loading models yet ‐ or rather ‐ I did, and then the code changed, so it needs to be done anew.
  • Delay module, in 'short' mode, does not get correctly initialized on patch load, it seems fine on patch recompilation though.

    Or actually … several parameters were not updated in the synth after for instance a range change on a mixer or when clicking an rnd button on a sequencer, etc. etc. Fixed that, it was introduced with the randomization features in the last couple of previous releases.
  • PerlinNoise - Perlin Noise Made some new noise modules with Perlin like noise, in which the roughness can be controlled and the pattern length. A clocked one and a free running one. New noise values can be inserted to change the pattern. The maximum pattern length is 4096, the length controls set a fraction of that. The number of layers can be set, more layers give more smoothness, at the expense of processing time. The new input when PerlinNoiseTrig - Clocked Perlin Noise unconnected is active, giving noise like behavior, when it is set inactive the behavior is tone like. When made active less frequently it will change the timbre. I'll probably make LFO versions for this too, welp, would like to at this time, it seems like a slowly clocked one can make nice percussion patterns. Also I'd like modulation of the length ‐ ok, added that. Not sure how strictly Perlin this is, I've tweaked the interpolation function from one layer to the next to more or less give the same amplitude for smooth and rough settinging (but it is random of course …).
  • With the above … there now are 200 module types.
  • PerlinTone - Perlin noise in tone mode And then when on the Perlin you do not set new values very often it makes sense to have frequency control as well. The maximum sequence length was set a bit shorter for this one (256 vs 4096 for the Perlin noise modules). This can make some nice metallic or tone like noise sounds. I should add a button to the Perlins to invert the new input. As it is now the new input is set by default, this is not always handy.

    I've added the invert option ( i(nvert) vs n(ormal), the latter being the default value on the noise modules, the former for the tone module).
  • RandomScale - A scale randomizer And another new module, Random scales … the help blurp says something like:

    This module implements a scale randomizer. Each time the rnd input goes from inactive to active, or when the rnd button is clicked, a new random scale mapping will be computed. A scale will always have 12 notes per octave, and all octave mappings will be the same (with an octave shift, of course). Within an octave the 12 notes will be randomly mapped to 12 (probably, but not guaranteed so, it's random after all) different notes.
  • Arpeggiator - A simple arpeggiator A simple arpeggiator

    On each clock on the 'new in' input a new input sample is is taken and added to a list of samples, the oldest value present will be dropped from the list then.

    This list can be left unsorted, it can be randomized or be set to play the lowest or highest note first .

    The list length is set with the length control.

    On each output clock on the 'new out' input the next stored value from the sorted list will be output.

    In random mode the order in the sorted list will be randomized when the playout wraps back to the first value.

    In unsorted mode the playout will be the recording order.

    On the input side an acceptance filter can be applied. All incoming values can be accepted, values differing from the previous value or values not present yet in the list of samples.

    The toggle input when inactive causes the selected sort order to be in effect and when active the next sort order will be used. This can be used to toggle between low to high and high to low modes, for instance.

    When there are not enough input values available (yet) arbitrary values will be clocked out until the playout counter wraps back to zero.

    The reset input (or a global reset) will cause the playout pointer to be set back to zero without changing any stored values.
  • ProbSequencer - A probabilistic sequencer And another new one, a probabilistic sequencer.

    For each note the probability with which it will be played can be set with a slider (and this value can be multiplied by the value on the associated input). Notes have to be be enabled before they can sound, and note enables can be selected from a scale preset.

    The presets will be dynamically loaded from a file wren.scale that must be in the same folder as the Wren executable file. When this file does not exist Wren will create it. After that you can edit it with a text editor (like Notepad for instance) and Wren will not touch it anymore.

    A selected scale can be altered with the note buttons, and such a change will be saved with the patch (making the shown scale preset name meaningless, of course).

    The rnd button will set a random probability distribution, the clr button will set a flat distribution. The distribution can be altered with the tilt control. A zero value means that there is no tilt, a positive value makes higher notes more likely to be selected and negative values will produce more low notes.

    A transposition can be applied to the selected scale with the trans(pose) control. C is the 'neutral' base note (not leading to any changes). Transpositions are not reflected in the shown note pattern. The low and high note controls limit the range of possible notes.

    The sm(oo)th controls determine the likelihood that the next random value is about the same as the current one. So with a larger smoothness the results will be less jumpy.
  • Added noise type selection to various noise modules (OSC and LFO). The default type is Linear (which was the only available mode before), the added types are Gaussian (with a fixed sigma of 1.0) and exponential (with a fixed lambda of 3.0). This affects the Noise, NoiseTrig, NoiseLfo and NoiseLfoTrig modules, but backwards compatibility was maintained.
  • Pattern - A pattern generator Added mode control to the Pattern module. A mode can be set on each step, it can be normal (nrm), random (rn1), weighted random (rn2, or rn3) or skip. Normal meaning that it will do it's full count. The random modes will generate a random number [0,Count] and use that as the step count. The first random mode considers all numbers in the interval, the second random mode only divisions by 2, and likewise rn3 uses divisions by 3. Skip will just skip the step. Also added individual step outputs which will go active when the associated step causes an output pulse to be made. The step outs will produce a 'per step' copy of the main output.
  • Added clear inputs to arpeggiator and poetry modules to allow them to forget stuff. These are latching inputs capturing a low to high transition. When they are in the set state a next value to be clocked in will not be the input value but zero instead. After having been processed the set state will be cleared.
  • AmMod - An amplitude and ring modulator Added an Amplitude / Ring Modulator module, which is a multiplier with control over modulation depth and modulation offset. This makes it a bit easier to apply less than full depth AM or RM to a signal. The input signal type can be set, and it can do a fade between amplitude modulation (AM) and ring modulation (RM).
  • Rewriter - A pattern rewriter module And made a simple pattern rewrite module for which a couple of rewrite rules can be specified, and an expansion level. There is a small alphabet of the letters A, B, C, D and E. For each letter a substitution is specified in terms of other letters from the same alphabet. For instance, given the rules:

    • A → ABC
    • B → C
    • C → D
    • D → AC
    • E → B
    Then a number of expansion steps is specified resulting in patterns being generated from the start symbol 'A'. With the rules above the successive patterns would be:

    • A → ABC
    etc. The maximum depth to be set is 8, which would result in a pretty long pattern already with the rules above.

    At each positive input step a next symbol from the generated pattern is selected and the corresponding output will be made active. At the end of the pattern it will start again from the beginning. Some rules (or all) can be left blank for simpler patterns. All letters must be from the set [A..E], everything else will be ignored for pattern generation.

    This is after an idea found at RobotPlanet, which in turn references this article.

    Decided to generate all 8 expansions whenever the rules change, which made it possible to have depth modulation ‐ which I've added.
  • RewriterNote - A value generating pattern rewriter Made a variation on the previous module generating values instead of events. It also has a couple more rules to compose with. It adds a lookup system so that for each active step a value is put out. The value knobs are mode controlled, one of the modes being 'note value'. There are the usual dB and linear ranges too.

    A common chain input is available which is simply added to the current rule based value, and then there are individual rule chain inputs which are added to the output only when the corresponding rule is active ‐ with this the module can be used as a rule based multiplexer too (when all values are set to a neutral C4 or to zero, depending on the selected mode).
  • TuneSmithy - A fractal-like note pattern sequencer A TuneSmithy module. This is a melody generator after an idea by Robert Inventor and it is explained at the website of the author. The sequence can be arbitrary long in principle, but decided to cap it at 1024 steps. The pattern is a comma separated list of integer values. The second link above explains the inner workings.

in version 2016.8.21.0

  • When during live morphing new modules are inserted some odd stuff happens. Ok, only when the module does odd stuff, see next item ‐ the GVerb module would crash. Ah, and modules get set to all zero values when inserted while live morph is active. Aha optical mostly … the first variation gets set from the default knobs and all other variations get set to all zeros, which looks confusing in a live morph situation. Still it would be better that on insertion of a new module all the variations would be be set the same ‐ according to the default knob positions. Ok, fixed that.
  • Live morphing when the GVerb module is present sounds bad (even when it is not being morphed), for FreeVerb it is fine tho. Ah, it was being recreated all the time even when the parameters did not change, and then it would crash. Ok, fixed it. But there also is the issue that automation will change parameters that it should not change. Ok, stopped that too.
  • Bug in DataGraph where the rightmost point would always end up top right (1,1) even when it would not be drawn there. Fixed.
  • The active variation randomizer got mixed up a bit with the randomize function from the morpher, unmixed that. The active variation randomizr is selected from the action menu or by pressing 'R' on the keyboard and it sets random values for the current variation only. The randomize function for the morpher sets random values for variations 2 to 6 (for quickly generating a handful of new genes).
  • Bug in ScaleQuantizer, the selected scale selection is not properly read from a saved patch, the buttons are OK though. Was an issue for all dynamic count selectors and got introduced with the introduction of variations. Fixed now.
  • Oopsie .. the filter inversions used '-' for 'off' (which can not work anymore after some changes on how dashes are handled for popup menus in relation to automation) changed them to '.'.

in version 2016.8.20.0

  • Tod - Time Of Day Made a Time Of Day (Tod) module which is a saw tooth LFO with a period of 24 hours synced to the local PC clock. So at 00:00 it's output value will be zero and at 01:00 it will be 1 / 24. The clock has millisecond resolution. The output value may drift a bit as windows does time syncs when it feels a need ‐ but it will be the best estimate of the current time. A couple of level shifters and ChebGen modules could be used to obtain signals that run faster. Like first make the signal bipolar, then multiply by 24 (first by 12 then by 2 using two ChebGens in saw mode) and then level shift it again to unipolar positive to get a signal with a rate of one hour. Then the same trick with a factor of 60 to get minutes, 60 again for seconds.

    Hmm … instead, I've just added a couple of outs for hour, minute and second.
  • Made a new option for the morpher, it can do a live morph over the breeder too now. Normal morphing is between the left and the right morph and morphing over the breeder uses all eight variations present in the breeder instead (when the breeder is morphed with the Morph button this is equivalent to the non breeder morph, but when mutate or mate is applied variations will be introduced). This new option tends to (depending on settings and actions) give more lively morph results (like for the XY controls the dot can then move in a rough curve instead of in a straight line only).

    soapy worms And made a new 'soapy' worm shape ‐ how cruel it now seems to hold them in a cage like this …

    I've turned the morpher code inside out a bit, that is, I've made variations for patches and based the morpher on that. Variations are stored with the patch, so they will still be there after patch reload. As the variation values are stored in the controls (knobs and such) now, this also means that module additions and deletions do not mess up the worms for other modules anymore. All this needs some work though still; the worms are not always updated correctly, and there is an issue with XY controls loosing data or something ‐ but it stopped crashing at least :-)

    Changed the randomizer as well, it now works through the same mechanisms as used by the morpher. It will set random variation values for the active variation now (which then in turn moves the knobs, the randomizer used to work on the knobs directly (which would then change the current variation)). It is all a little easier this way. Anyway … some more work to do on this.

    Most stuff is working now, but drag-drop of worms is messy still … some more work …

    But it's not working well; turning some more stuff inside out ‐ the mutations are all carried out on the patch now and then update the worms, instead of working on the worms and updating the patch. Let's see what surprises will arise from that …

    Ok, that goes better, it seems to all work now as it should ‐ except for it being very slow all. Not sure if its the editor updates or the worm updates … there are a lot of params that change on a live morph … more work :-)

    Improved the speed somewhat, still not very fast, but it will do I guess.

    Livemorphs are controlled trough the lights update routines, that is not ideal (as the tempo goes all over the place) and this should be changed. Ok, changed that, it is currently updated at a rate of 10 Hz triggered from the audio generation rate (and so independently of the lights update rate). So this should work properly for recording to disk as well. The exact rate may change later from 10 Hz, not sure yet, or make it a user pref maybe.

    Live morphing works over the variations now, and I've removed the left/right morph worms. When a left/right morph is wanted you can do a morph operation on the breeder, then copy the worms to the variations and then perform the live morph. So with less options the same functionality is still available.

    toobar with variations Added a couple of buttons to the randomizer / morpher screen to make copying easier. Drag / drop now works properly as well. Moved the live morph options from the randomizer to the main toolbar ‐ turn auto mode on or off, and the morph control knob. Morphing no longer changes any variations, instead there now is a temporary variation which is being used.

    Changed some keyboard shortcuts related to the randomizer / morpher and added some for variations:
    • R - randomizes the patch (was Ctrl+Shift+R).
    • Shift + R - toggles the exclusion visibility. (was Ctrl+Shift+Alt+R)
    • Alt + R - shows or hides the randomizer window.
    (Ctrl+R still is recent patch reload).

    For changing variations you can use the keys 1 … 8, or they can be selected by clicking on a worm in the toolbar or from the View menu. Variations can be dragged from one spot to another, or even from or to the randomizer window.

    Made it so that it is still possible to see all of the toolbar in the space needed for four horizontal modules … which is like 1024 pixels. This would be a practical minimum value for the horizontal screen resolution needed for Wren (see image above). And also added the mutator commands in there (as well as into the action menu).

    Had to change the patch format again … not really for the variations, but could not store the active variation with the patch in the current format. Made the format a little more flexible again, so that future patch parameters will not need a new patch format (which already was the case for control and module parameters). Anyway, it's backwards compatible, but not forwards, as in: old patches can still be read.
  • Auto - Auto-randomize, -mute, -mate or -morph Made an Auto module which can perform Auto-randomize, -mute, -mate or -morph in the same way the buttons in the randomizer / Mutator window do. Making this a synth that can truly auto-mate!
  • The '-' avoidance code has a bug it seems … causing Wren to hang in an endless loop on some patches when the randomizer is used ‐ investigating. Ok, solved that, but still saw dashes on morphing … fixed that too.

    Which … of course … introduced an issue for selectors having only two values and no dashes at all, fixed that too.
  • The PitchShift PitchShift - Pitch shifter module can not support randomization on the delay parameter. I disabled that. The problem is that when delay and shift are changed at the same time invalid internal values can occur. All automation has to be and was set disabled for that knob.
  • When a control was set to be non-randomizable, or non-automatable actually, and in the patch it was stored to allow for randomization the red exclusion rectangle would not show. Fixed that, and when such a patch is saved the control will be saved as non randomizable too.
  • PitchShift module would produce denormals under some conditions. Probably fixed it with normalizing the linear interpolation code's output.
  • Gabe made some new bitmaps for the looks. I've made some new ones too – had a lag of about 40. Looks file got updated to 2016.8.2.
module glyphs randomizer

in version 2016.7.27.0

  • Fixed the patch randomizer for selectors having '-' values (these are meant to generate separators in the associated popup menu). Trough the menu interface such items can not be selected, but the randomizer found 'm allright …

    Ah, and clicking on a selector or using the cursor keys or the space bar hits them as well. Fixed that too.
  • Made the Pad, Spiral and DataGraph modules randomizable.
  • I'm working on a patch mutator, it's very much like what the G2 has. Still some quirks to iron out on that, like what to do when the patch gets modules inserted or deleted. The current implementation does not handle that as it should. Also the images seem to not always be drawn correctly. Ok, found the issue, I'm misusing, sort of, some selectors as indicators (on the ScaleQuantizer). This means that the chord selector has to be disabled for randomization. It should maybe also indicate that the key selection does not map to the selected chord anymore. But then again … I could just consider the selector to be a preset selector only, not reflecting the actual state. On a patch reload the actual keys will win anyway. I may change this when i get ispiration.

    I've made a FAQ entry for the morpher / randomizer.

    The Wren forum thread may have some info not listed here.

    Made the mutator work for Pad, Spiral and DataGraph too. There are some issues with the DataGraph, as points can be added to or removed from it. This means that the number of data points present in the mutator may change. What I did for now is that such a situation is detected and the mutator will be re-initialized (which looses all the current worms in the mutator, making a random set of new ones, and the scratch area will be cleared). Module insertions and deletions are handled in the same way.

    Added two extra worms to the mutator, a left and a right morph, and a knob to fade between these two. Also added a modulation option to the knob, and a new module which can do the fade from the patch. This works at the lights rate, which is user controllable, but it can not be very fast nor can the exact timing be very predictable, as a lot of screen updates need to be done. Still for slow morphs between two variations it would be nice. It is possible to have more than one LiveMorph module in the patch, but things may get a bit jumpy with that.

    The randomization exclusion works for both the randomizer and the mutator in the same way. There is a keyboard shortcut to visualize the exclusions, and also when the randomuzer / mutator window is active exclusions will be made visible in the patch (with red rectangles around the excluded controls or modules).
  • Made it so that when patch randomization is requested (as opposed to single control or single module randomization) and there are no modules selected, that all (randomizable) modules are randomized.
  • Changed some code for the components introducing a couple of interfaces for them: IAutomatable (for MIDI control), IRandomizable (for plain randomization) and ICollectable (for controls that can contribute to the genome used for patch mutation). This makes things a bit easier to program, I hope … it was quite some work. Please note that non automatable controls can not be randomized either. In general anything that needs patch recompilation can not be automated or randomized.
patch randomizer / morpher

in version 2016.7.23.0

  • Reverb - Reverb Made a scale control for the Reverb module. It sets the internal length of the delay lines to some factor of the original length. This alters the color and buzziness of the reverb. As the lengths of the internal delays are modified a change of scale needs patch recompilation( e.g. a change causes a brief silence).
  • EnvAHD - AHD Envelope Added an End Of Cycle (EOC) output for the AHD and ADSR envelopes. When fed back into the trigger input turns the envelope into an LFO, but can it be used to chain envelopes as well such that one triggers after another.
  • Moved the Constant, Amplifier and Ratio modules to the Math tab. This distributes the modules a bit more evenly over the tabs.
  • Working on a patch randomizer. Randomization is possible on Knobs, Sliders and Selectors. It is possible to randomize a single control, all controls on a module, or al controls on a selected set of modules. There will be options to disalow randomization on selected modules and on selected controls. The action menu will get an option to make visible the modules excluded from randomization.

    Made a randomizer control wimdow to make it possible to exclude module types and control types, partly by category.
  • For the randomizer I had to change the patch format to allow for a new module parameter type. Old Wren patches can still be read by the new Wren but new Wren patches can not be read by old Wren versions. I did make the change in such a way that in the future it should be possible to add new module parameter types without altering the patch version. This already was the case for new detail (knob etc.) parameters. Old Wren's should then just skip the parameters they don't know about.

in version 2016.7.4.0

  • popup menu for DataGraph / DataMaker Made a popup menu for the DataGraph, or for it's DataMaker component rather. Some wave shapes can be selected and some basic operations on the data can be selected. With the symmetries there are some duplicates in the operations, like a Bell shape is the same as a vertically flipped cosine, and for the squares there are some duplicates as well. Added load from file and save to file to the menu. Added a left – right adjustment feature as 'make loopable' to the context menu.
  • MixMS8to1 and MixM16to1 were not working without modulation signals being connected, fixed that.
  • The timer controlling the lights and VU meter updates is started in running mode. When the startup is slow for some reason this may cause the VU meters to be updated from non‐existing objects. Fixed that by disabling the timer at startup, after each patch compile it was turned on already, so things should be all fine once an actual patch is present.

    Decided to make all timers inactive during startup to enable them only in FormShow or even later – when needed. Also typed some extra checks around the VU meter calculator objects to see if they were allocated before being used.

    MIDI TX messages were logged from the audio thread directly (when logging was enabled), which was a bug. Fixed that.
  • Error in DataGraph module. It was meant to react to double left clicks or ctrl+left clicks by adding a new data point, but ctrl+double left click would add two points and would then mess up the order of the points. Fixed that and checked at other places if such a problem could exist elsewhere ‐ did not find such places though.
  • There is some debug stuff left in the looper module (like the light), this should be removed once the thing gets settled … which currently it is not.
  • Delayed help file creation a bit so that the looks are completely set up before the images are being created ‐ image previews on the module selector look better now.
  • Made the trigger LEDs for the envelope modules light up 125 ms always, even for very short trigger pulses. Some more will follow as some modules output very short trigger pulses that could not been seen on all input lights. This also means that for a non changing input signal the light will go off after a while, it will only show the trigger moment. made an error in this making the sample and hold turn into a track and and hold … and fixed that again.
  • It may be the case that there is a denormals issue for the Formant2 module, running some debug tracking on that, but lost focus … focusing again … After 10 or 11 hours of runtime on a patch, yup, got a denormal report, looking into the why now, it is on the output signal, should not be possible inspecting the code, odd.
  • Restyled the module documentation a bit and added a link to it in the main menu of this page. Also for newer modules I started to add links from the module images in this page to the documentation page (meaning that module images here are clickable now). Also fixed some inaccurate help text.

    I've started using a mark‐down processor for easier markup of the generated help file. See the Acknowledgements section for more on this. This will allow for clickable links in the help, better looking lists, etc., Expect more help restyling.
  • Changed some things for popup menus. They should now popup near where the cursor is instead of near where the top‐left of the control happens to be. Also in the patch editor I've made the menu key work for the element the mouse cursor is on.
  • Moved wire toggling and wiggling from the edit to the action menu, keeping the same shortcuts (Ctrl+space bar and Ctrl+W)
  • MixQS2to1 - Quad stereo 2 to 1 mixer MixQS1to1 - Quad chainable stereo 1 to 1 mixer QuadPan - Quad panner Made three new mixer types MixQS2to1, MixQS1to1 and QuadPan (which actually is a panner, but it's on the mix tab …). Although these do have blue connectors they are intended to be used for audio mainly and when audio signals get connected the connectors will change to the audio rate color. The panner uses an equal power distribution only. The mixers allow for 24 dB of amplification.
  • FastToSlow - FastToSlow converter Made an audio to control rate converter, which can be used to keep large areas of a patch from becoming red.
  • LfoTrig - Retrigger option added to LfoTrig Added a 'retrig'(ger) option to the LfoTrig module. When set into retriggerable mode and when the trigger input goes inactive and active again during the current pulse train the module will be reset to start the train anew. The default setting is 'normal' for compatibility with older patches. Together with the DataGraph module this could be used to make retriggerable arbitrary envelopes, for instance. Hmm … not quite … anyways …it seems useful … maybe.
  • Added a Polar Polar - Rectangular to Polar conversion module, it translates rectangular coordinates into polar coordinates.
  • Added a Rectangular Rectangular - Polar to Rectangular
          conversion module, it translates polar coordinates into rectangular coordinates.
  • StereoLooper - A stereo looper thingie Made a stereo version of the looper. It still has the drawbacks of the mono one, but really wanted stereo.
  • Added a Spiral module, an experiment really. Per spiral winding of mouse movement a settable amount of note steps is added. Along the positive X axis the white places correspond with the steps. As this internally works with polar coordinates I made outputs for the angle (phi) and distance / radius (norm) as well. The len output Spiral - Spiral controller represents the spiral length for the current (X,Y) location (from which the note output is calculated). So at least it doubles as a Polar sort of Pad module. (But the latter can also be done by adding a Polar module after a Pad.)
  • Added an unattenuated frequency control input for the Lfo, SquareLfo and RandSig modules. This makes it easier to add overall speed control to a patch.
  • Added an MConst module for selecting some more or less often used mathematical constants, like 1, 2, e and 𝜋 etc. MConst - MConst for math constants
  • Added a 'wrap' mode to the DataGraph module, the standard behaviour was 'clip', which still is the default. In clipped mode an out of range input value will clip on one of the graph edges and in wrapped mode it will wrap around and come in on the other side again (modulo operation).
  • Monadic - Monadic function Added f(x)=x·𝜋, f(x)=x·2·𝜋, f(x)=x∕𝜋 and f(x)=x∕(2·𝜋) functions to the Monadic function module. Also added f(x)=floor(x), f(x)=round(x), f(x)=ceil(x) and f(x)=abs(x).
  • The Pad and Spiral module did not set their output values after a module load or patch change, it needed a movement first ‐ I've changed that. I may have thought this to be a feature for the Pad module, but for the Spiral it was just a plain bug.
  • Removed all the all-too-obvious email addresses from the web page and documentation.
  • Removed some unused stuff here and there from the code, making the executable a tad smaller.
  • Added some volume damping around patch recompile operations, the worst of the recompilation click is out now.
  • I've made an option to disable automatic doc file generation. This option is off by default (so docs will be generated out of the box), and this feature will only work when you use the old wren.ini file, e.g. when you copy the new executable over the old one (or copy the old ini file to the new location). You can always manually generate documentation from the Settings Screen F3 by using the 'generate documentation ...' button there. Note however that when no docs were generated the popups from the module selector will not show a module, or an old version of the image.
  • I've added command line passing of a patch file name. You can now associate Wren with '.wren' patches in windows such that double clicking on a patch will open it in the Wren instance that got associated. It is still possible to run multiple Wren instances, but they will have to run from different directories now, and patches opened through the explorer will always open in the associated instance. When starting Wren directly it will still open the last patch it had loaded as well. BTW it is possible (it has always been) to copy patches, or parts of it, from one Wren instance to paste them into another) or into a text editor, or whatever program that will accept text.

in version 2016.6.5.0

  • Changes in text controls and data graphs marked the patch for needing recompilation which was overkill. It should have been marked for change only. Changed that, and internally renamed some 'PatchChanged' stuff into 'Recompile'.
  • While all modules seem to be properly execution locked now during heap operations the patch as a whole was not locked. Changed that.
  • MIDI CC assignments to knobs are not working properly ‐ CCs move the knobs alright but the synth value is not changed. Ok fixed that, but now on very fast MIDI I'm getting all kinds of memory issues. Ok, that actually is due to some errors in MIDI transmission ‐ it was doing memory allocations from the audio thread. Ok, four bugs fixed in this … messy, but fixed now.
  • Added exponential FM control to looper. Oh that it was no longer clicky was a mistaken observation, with long loop times or record being off it is not too noticeable maybe. And a remark about the interpolation mode, all pass mode is not to suitable when the interpolation point moves relatively fast, that is for largish modulations.

in version 2016.5.29.0

  • The CubicClip module could generate denormal values for small hysteresis and alpha values combined. Fixed that.
  • When a text editor popup appears the wires of the patch will now be temporarily hidden, and once the editing is done they will be set back to the state they were in when editing started. This solves the problem where text to be edited was not nicely visible when wires happened to run over it.
  • I've changed the Normalize function to now filter out denormal values, small values, inf's and NaN's. Like:
      function  Normalize(const aValue: TSignal):TSignal;
        TWordArray = array[0..3] of Word;
        PWordArray = ^TWordArray;
          (((PWordArray(@aValue)^[3] and $7ff0)-$10) >= $7fe0) or
          ( Abs(aValue) < NORMAL_LIMIT)
        then Result := 0
        else Result := aValue;
    This does add a little extra run-time overhead - but less than 1% or so on a 90% patch. The NORMAL_LIMIT value is at -400 dB, TSignal is a Double.
  • Made text changes mark the patch as being changed, so they can be undone. Also made undo work for the new graph control.
  • Fixed the patch profiler (only for the profiled versions, not for the normal release version) to work properly for RateSmart modules. (Profiling adds about 8% performance overhead, so it is turned off for release versions.)

    And then removed a lot of needless profiling info from the report.
  • The 1 kHz fader for the third filter bank was wrongly named and hence that band was not working at all - fixed it.
  • The GVerb module was not properly locked against execution when it was being recreated, fixed that one and two or three other cases as well. Looks like overall stability got improved with that, in that undo/redo keeps working etc.
  • Error in MIDI running status processing. Only the first two bytes for messages based on running status would get interpreted. As for $90 $01 $02 $03 $04 only a note‐on with velocity 2 for note 1 would be produced and the note 3 with velocity 4 note‐on event would never get processed. Fixed that.
  • Sped up patch execution by about 5% trough removing some dynamic type checks from the inner execution loop. And by another 2% or so by skipping some profiling related code for the release version of the code. Sped up the dezipper code a bit too ‐ but that's not really noticeable (as to be expected I guess as it works at control rate).
  • Added filter inversion for all filter bank modules. The idea is to invert every odd filter before the summation occurs and to not do that for the even filters. After doing some filter sweeps this does not seem to alter the filter response much though … it gets a little less bumpy (judged by listening), but then again it does not cost much. processor wise, so will leave it in anyway.
  • ClockGen - A clock generator module Made a clock generator module that acts like the Clavia ClkGen module. It can not sync to MIDI for now. The blue outputs have the internal phase accumulator values, these can for instance be used to implement your own swing functions by feeding them into a comparator.

    Added an input for external tempo control, this overrides the knob setting. This makes it possible to control the tempo with the Tapper module, which got a new BPM ClockGen mode added for that purpose.
  • Count - A counter indicator Made a count module, it counts upgoing signal edges on it's count input and it displays the total count. A frequency measurement tool would be handy as well (which would be a counter with automatic periodic reset).
  • FreqCount - A frequency counter indicator OK, made a frequency counter module as well, it counts upgoing signal edges on it's count input and it displays the total count over the measurement period recalculated to Hz. It is a bit of a primitive thing ‐ like you have to wait for 10 s to get 0.1 Hz resolution. But seems handy to have still, and maybe will expand a bit on it at some later stage.
  • SeqRandVal - Y.A.R.S. Yet Another Random Sequencer! When quantize is on the internal values will be quantized according to the note fraction quantization value selected. When quantize is off the plain random values will be used as the internal value. The chain input is never quantized but just added to the current internal value after all other processing. The built in slew rate limiter can be applied either pre- or post-quantization, it does not act on the chain‐in value.
  • Experimenting with speech synthesis a bit. Made a very simple speech module based on the Tiny Speech Synth. In the current setup it translates a sequence of phonemes to an internal wave file that can then be played just like the wave player does. tts experiment with tss

    Will need to rework this a bit to make it create sound on the fly. The idea is to make something like shown in the image (the 'song' module below). The module should flag text start and phoneme starts. With these signals sequencers can be driven to control the speech rate, the oscillator pitch and the amount of whisper.

    Getting there slowly … re-implemented the internal oscillator, so it can be properly tuned. Still struggling a bit with extreme duration modulations that are causing crackle ‐ phoneme overlap is a bit of a PITA. And speech is not very intelligible, but not worse than say a human voice trough a G2 vocoder … maybe.

    I've changed the 'duration' control into 'speed', added oscillator wave form selection (saw or pulse, both anti‐aliased). Added a filter configuration control as there was some odd pole or zero stuff going on in the normal mode which still may be interesting … but it can be turned on or off now. This works by inverting every odd filter's output before summation in the 'FI' mode.

    Song - TTS experiment with singing Changed the speed modulation a bit, but it is still not perfect ‐ clicky at times. The PM I've added is quite useful though. Also I've added some more outputs, one that goes active on each 'silence' and another going active on each 'vowel'.

    I've made the default speed quite low (or actually the phonemes are quite long), to allow for very slow textures, but it can be sped up by a factor of 10 or so when using external speed modulation.
  • Vosim - A VOSIM thingie Made a VOSIM thingie. It is meant to be driven by an oscillator to set the rate and it can then control a single formant. Added 'Whisper' to make noisy tones, and AM to set the volume dynamically. The number of pulses can be modulated as well from one to the set number. The decay parameter controls the attenuation after each output squared sine pulse. The number of pulses and the decay factor determine the formant strength. The formant frequency is controlled with the formant parameters.
  • Graphical control linear mode Working on a new type of graphic control which can be used as a lookup element. For example in this new DataGraph module. The input would expect a [0,1], [-1,0] or [-1,1] signal and the output would then output the Y value for that X value also [0,1], [-1,0] or [-1,1]. It should be possible, when finished, to add points to and remove points from the graph. It would probably do linear interpolation to find Y values, but it's just an idea for now – working on it … currently it's an image.

    Ok, it is a working control element now that can be used on modules. Points can be added by double (or control) clicking into an empty area. Double or control clicking on a point allows the point to be moved. Removal of a point is just a move to somewhere out of the control. There is a minimum of two points in the control, one on the very left and one on the very right – these can only be moved up or down and can not be removed. There is a restriction on horizontal movements too, a point can not be moved to after or before an existing other point.

    When moving a point a crosshair cursor is shown, and in play mode a vertical bar cursor will be visible to indicate the current playback position. Not sure yet how that will work out at audio rate playback. Now to get a first working module with it … not so bad … good actually, the moving vertical bar works, now the rest.

    Graphical control smoothed mode The compiled synth now gets updates from the control on patch load and on point moves, just a little more work now in updating the synth data and making an interpolator for it.

    We have lift-off! After fixing some memory issues, of course, and some small tweaks … like decorating the dots a little and making it a transparent control :-)

    And now with splines too. Turns out to be not too bad for lower audio rates :-)
  • TypeFlip - A type flipper module Made a type flipper with slew control. A fixed input signal type can be set and for the output a left and a right type can be selected. When the select input is low the left output type will be applied to the left output and the right type to the right one. This is flipped when the select input goes high. The speed of type flipping is controlled with the slew parameter ‐ when slew is set low the switch is immediate, when it is set to the maximum value the flip never actually happens. The selectable signal types are: 'normal', 'inverted', 'positive', 'positive-inverted', 'negative' and 'negative-inverted'.
  • Looper - A looper thingie Working on a looper thingie - it is a mess right now … well it basically works but it's clicky still. Added some mixing around the end loop to begin loop transition regardless of whether the playback pointer moves forwards or backwards. This helps somewhat … The amount of overlap can be set with the overlap control from zero to one.

    Changing the pointers to be relative to the in‐pointer helps more. Sounds like it is click free now. Loop readout interpolation can be set to either linear or all pass mode. Both are having different artifacts, but linear seems to work better for long delay times and all better for short times. The maximum time can be set from 110 µs to 5 minutes. Duration and start controls are set as a fraction of the maximum time. Speed can be set from -4 to 4, negative speeds meaning the playback is backwards. For longer loop durations the modulation of start and duration are quite sensitive, decided to make the amount controls to work logarithmic.

in version 2016.4.27.0

  • There was a bug in how the selectors worked, setting the value to zero by clicking on the selector instead of using the left mouse click popup menu would not set dependent modes correctly. Fixed that.
  • There was an error in the stereo RMS calculation used for the compressor. It calculated the RMS of the sum of the left and right signals where it should have calculated the root mean of sum of the squares. Changed that, it works better this way.
  • Fixed the range setting for the MixMM16to1 module.
  • Changed the looks a bit for this web page, checked the spelling for it (and for the module help) a bit better, updated the online module docs and updated some of the module help texts.
  • IntDif - Integrator differentiator I've made the IntDif module rate smart, it would not otherwise differentiate control rate signals the preferred way. Also added a gain control for the integrator to make it possible to avoid clipping. Also made a horizontal slider control type for this. Transparency acts on the differential output only and gain on the integral output only.
  • Envelope - Envelope follower Adding RMS mode to the envelope follower module. Note that in RMS mode the RMS averaging filter time is set from the Attack time, which is a bit odd, but setting it from the Release time seemed even less even.
  • Added a 'saw' mode to the ChebGen module. The image shows this mode for the order five output for some standard input wave forms. Basically this is:

       out := FloatMod( N * ( in + 1), 2) - 1;

    This would 'sort of' work for non integer N as well. Will make a separate module for that, the SawMill module.
    ChebGen module in Saw mode order five for some input wave formats
    (Also changed the graph colors back to something a little less psychedelic.)
  • SawMill - Sawmill module Added the SawMill module. This module is rate smart and will switch to audio rate when such a signal is present at one of it's inputs. The frequency multiplication proper only works for integer multiplication factors, for non integer factors it is more like a PWM effect on a sawtooth wave (that is the 'sort of' disclaimer mentioned in the lemma above). This is quite a nice effect on sine or triangle waves as well. This is a naive implementation … up to like 200 Hz this is sort of OK.
    Example output for the SawMill with modulation in the range [1.0, 5.0], controlled by the red triangle wave. The blue signal is the input saw and the green signal the frequency multiplied saw:
    saw mill example output
  • pulse modes Added pulse modes to the divider modules. They can now give a square output, a pulse output (a copy of the current binary value of the trigger signal) or pass the analog trigger signal's current value when it is larger than zero and false when it is not. The output level to be used for falseness can now be set on the divider modules too – see next lemma.
  • Logic output levels Added output level selection to some logic modules. The default mode will always be bipolar and non inverting to be compatible with the old situation. Any lights will still show the internal logic state independent of the selected output type.

    Added this for the divider modules as well now.
  • Added a 5 to 1 MixS5to1 - five to one stereo mixer and an 8 to 1 MixMS8to1 - eight to one stereo mixer stereo mixer to save some screen space in patches with many stereo mixers.
  • Made a phase distortion module, after an idea found here. The input signal is fed into a (short) delay line, and the delay time is being modulated with a low pass filtered copy of the input PhaseDistortion - phase distorter signal. The modulation depth can be set and modulated by an external signal. In addition to the modulation from the filtered input signal The delay time can be modulated by an external as well. The filter Q can be set and it's cutoff frequency can be set and modulated.
  • Added Hysteresis to the CubicClip module, and moved it from the Control page to the FX page (but it still can run at control rate as well). The default Hysteresis value is zero for compatibility with old patches. It is very possible to let this module clip now into one of it's two extreme states due to the positive feedback used for Hysteresis control. I'll consider this to be a feature.

    Hysteresis example:
    Example for Hysteresis on CubiClip
  • KS - Karplus Strong module Added an option to choose between two modes for the fractional delay calculation in the KS module. It used to have linear interpolation only, but can now do all-pass interpolation alternatively. The difference is a bit more subtle than I had thought it to be, but still may add this to more delay based modules.
  • AllPass - Allpass filter Added an AllPass filter, which is a delay line with feedback and feed forward around it. The feed amount can be modulated, which moves the frequency for the 'halfway phase shift point'. As it is a delay based algorithm it ended up on the 'delay' page. The delay time is specified in (whole) samples, so the actual delay time depends on the currently set sample rate. I put this in mainly to do some more experiments with phase distortion on arbitrary signals, it may be useful too for reverb experiments … or to help make stuff LAWDy like (by smearing out peak energies a bit for impulse like sounds).
  • Rungler - Rungler module Added a Rungler module. This is after idea from Rob Hordijk. It is to be found amongst the logic modules. The idea is to let the Rungler control the frequency of an oscillator where the output of that same oscillator goes to the data input of the Rungler. The clock input is then clocked by an LFO, or faster for weird effects, and from this little semi random patterns will emerge. For more info see http://hordijk-synths.info/ (which is not Rob's own website). It is nice to put some note quantization into the frequency control feedback loop (for tuned patterns). This module is rate smart, it will switch to audio rates when needed.

    I've made the number of taps used settable as well as the shift register length. It is possible to set the number of taps larger than the length of the shifter, this will result in non proper working. Default settings are 8 shift steps and 3 taps, like the original circuit has them. The output value is scaled with the number of taps to always have a range [0.0, 1.0], and after that a final level scaling is applied.
  • Measurement ranges for Value module Added some measurement ranges for the Value display module. Possible settings currently are : 'units', 'dB', 'Freq', 'Note', 'Lfo fast', 'Lfo med', 'Lfo Slow', 'Lfo BPM' and 'Lfo Lin'. All ranges assume the associated module parameter to be set to it's minimum value and the modulation input to be fully opened for a bipolar control signal. I.e. for the LFO fast range it is assumed that the speed is set to it's minimum value (0.254 Hz, knob position 110) and that the 'fm' control knob is set to the max (1.000).
    In the image shown the current cycle time for the bottom LFO will be 10 minutes and 36 s. (The top LFO provides the modulation for it.)
  • PulseDelay - Pulse delay module
    Pulse Delay mode delay
    Pulse Delay mode stretch
    Made a logic pulse delay module which can either delay an incoming pulse or stretch the length of it. The delay/stretch time can be set to the same ranges as available for envelope times, and it can be modulated.
  • Added positive and negative Q modulation to the SVF filter.
    SVF - SVF filter
  • Tapper - Tap control module Made a tap control … as in tap twice and it gets the tap rate from that to control LFOs with, or delay times. There is a rate multiplier which can set a factor of the tap rate to be applied to the control output. Also added a slave input and output to allow for chaining of Tapper modules (so one can be in LFO mode and another in DELAY mode,or a different rate multiplier can be used). Tap rate can be set by clicking the mouse on the tap area or when the keyboard focus is on the tap area (when it has a red colored border) the space bar can be used as well. It is also possible to set the rate with a knob, or by typing it in directly.

    There is a sync output which goes active on every tap action, and also the sync button can send a sync signal independent of the tap control (this is meant for resetting LFO's, for instance).

    An example patch for the tap control:
    tap control module example patch

in version 2016.3.5.0

  • 2016-02-20 : A user reported that when the windows theme is selected the text used on the module selector tabs is too large (not fitting the buttons). The styled font drawing for the module selector is a bit tricky, made a change to TKnobsModuleSelectorStyleHook.DrawTab which might help, at least the font is controllable then from the form designer … and no longer defined by the component's owner, so should be fixed to 8 point Tahoma now.
  • Fixed the memory leak in the TextSequencer module, it was present after all.
  • Pulser - Pulser module A new module, the Pulser. This is after an idea from Ian Fritz. This module only implements the pulsing bit though, and not the wave wrapper. The pulsing works by letting trough the 'signal' input when it's absolute value is larger than the 'shape' input value. When this is not the case the output is zeroed. To get the full implementation of the Wavolver the 'inact' output could be used to control mixing in some other signal, for instance from a wave wrapper module. This output goes active when the main output (out) is inactive (zeroed).
  • Formant2 - Formant2 module And another new module, the Formant2. This is a formant type of filter, or a vowel filter, for which presets can be loaded from a file.
    Sofar I've typed in formant sets named swedish, usa, french, csound_alto, csound_bass, csound_countertenor, csound_soprano and csound_tenor. See the supplied wren.formants file for details. Not all formant sets are equally well specified, only the csound ones did specify levels and bandwidths.

    The filters used are second order State Variable Filters used in bandpass mode, one for each formant. Bandwidth is being set by calculating a Q value and applying that. When no bandwidth was specified a Q of 10 will be used.

in version 2016.2.14.0

  • Tested Wren with the JACK Audio Connection Kit, looks like it is working fine here, but note that you'll need to select some channels to be used from the audio setup. I've added a FAQ item for this.
  • There is an issue with MIDI connections, when the server can not be found there is an endless amount of popups telling so. Ok, fixed that, and a couple of other possible ways for the NetMidi connection to go haywire. When something fails unexpectedly the auto connect feature will be turned off now, and error messages will go into the log instead of into a popup window.
  • There is an instability in the Formant filter in that it makes huge signal levels when modulated at audio rates. Ok, can fix this by setting the update rate lower, at a tenth of the control rate it seems to behave better – set it to 1 / 20 to be sure and at 44k1 this still seems smooth enough without filtering (update rate is then about 275 Hz).
  • An idea came in to make double click on a cable work like ctrl+normal mouse click, i.e. move or delete a connection.

    This was supposed to be working, but the double click was tested at the wrong point in the code, fixed it.
  • Added an average (avg) output to the Median module, it outputs the average value of all samples present in the sample bin. This provides a linear moving average, as opposed to the exponential type the Average filter and the Slew module use.
    Median - Median module
  • Added a simplified version of the Karplus - Strong oscillator. This one uses less CPU, the noise stuff went out and modulation update frequency was lowered to control rate. Also the brightness modulation was removed.
    KS - Karplus-Strong module
  • Changed the data buffering for the scope module a bit, seems to work better that way.

in version 2016.1.24.0

  • Thanks to Gabe I found a bug in the sample rate switching mechanism. Or two actually. First one would freeze Wren when using legacy audio and switching the sample rate. Second one caused general protection faults in the PitchShift module on a sample rate change. I've fixed those.
  • Looks like I fukt the math modules … if they ever worked … something to look into. Ok, it was only the monadic function module, fixed now.
  • The Third filter had some trouble with denormals, changed the code a bit, this affects all the multi-filters.
  • Solved the no-drag issue with module imports. Also made a distinct module import / export folder to be remembered over Wren sessions. This introduced a problem with regular module insertions … modules sometimes jump to silly places now … will need to check that. Found a quick and dirty patch for it, this will need some more attention at some stage (as the underlying issue is one that has been present for a long time already), but it's fine for now.

    Module import and export:

    module import and export
  • Made regular patch folder and template folder to be remembered over Wren sessions.
  • Added an Alternates item to the module pop menu, this can be used to change the type of the selected module. After the change it will try to reconnect the module (based on connector names, where they exist in both the old and the new module) and it will try to copy over parameters from the old module to the new one (based on control names, where they exist in both modules). Wire and parameter copying is not always possible however as there are some naming inconsistencies between modules (and to solve those would mean old patches can not be read anymore, not naively at least).
    alternate module selection
    And while at it … implemented non strict parameter paste as well, where you can copy over values from one module type to another type. Only the matching parameters (name based) will be copied in that case and the rest will be skipped. This fuzzy parameter pasting can only work from one module to another.

    This does not really work like I'd want it to work yet … it needs some more work.
  • Added peak / RMS mode selection to the compressor module. It used to do peak mode only.
  • 2015-09-24 : Different distribution laws for panner, say power law or volume law.

    Added some different fading curves for the XFade and Pan modules: linear (equal volume), square root, sine (equal power), sine squared (s-shaped) and squared.
  • Added a mixing level scaler, an "attenuverter'" like thing. The MixingScaler is on the Control page.
    MixingScaler - fourfold mixing level scaler
  • Added a a stereo widener module. For signals that are stereo already the base can be widened by raising the inversion amount, this adds a bit of -L to R and a bit of -R to L. For signals that are mono some delay can be added, amount and delay time can be set. Modulating the delay time will result into a flanging effect. This module can be found on the FX page.
    StereoWiden - stereo widener
  • Added a smaller mono mixer, taking less patch space. It has one input less than the other mono mixer, but is still modulatable, mutable, chainable and rate smart. The MixM3to1 module can be found on the Mixer page.
    MixM3to1 - three to one mono mixer
  • Added a volume control, with a preset, a mute and modulation. The Volume module can be found on the Mixer page.
    Volume - volume controller
  • Wren is now four voice paraphonic or limited polyphonic! Added a couple of note stealing algorithms 'none', 'cyclic', 'softest', 'oldest', 'lowest' and 'highest'. I've added level inputs too, note stealing can use that information (for the 'softest' mode), these could be connected to voice envelope outputs for instance. You'd still need to patch out the voices manually. The MidiMultiNoteIn module can be found on the I/O page.
    MidiMultiNoteIn - MIDI multi note input module
  • Added an RMS module, calculating the RMS value of it's input signal. The averaging time can be set with the time control. The RMS module can be found on the Math page.
    RMS - RMS module
  • Was asked for a utility module just displaying the value on it's input, made it and it can either show units or dB values. The Value module can be found on the Utility page.
    Value - A value indicator
  • Added a soft clipper with a cubic transfer function.
    CubicClip - A soft clipping module

in version 2015.12.15.0

  • The Hrast filter had a denormalization issue for the 24 dB section, added normalizing code there.
  • LevelConverter was not working properly, it took the input mode setting for both the input and the output mode (and so it acted like a .. wire).
  • Removed some the InternalName stuff, there were two mechanisms with one not being used.
  • Cleaned up the source code a bit by removing unused pascal units.
  • The previous distribution had an old version of the executable in it – fixed that.
  • New module type, a ScaleQuantizer, which is a NoteQuantizer with user definable scale presets.
    ScaleQuantizer - Scale quantizer
    The presets will be dynamically loaded from a file wren.scale which must be in the same folder as the Wren executable file. When this file does not exist Wren will create it, after that you can edit it with a text editor (like Notepad for instance) and Wren will not touch it anymore.
  • And yet another quantizer, a modulatable one. That is, the quantization steps can be switched on or off by both a selector and a logic input signal (the logic xor of those two signals). This one is a lot of fun actually, it can do trills for instance.
    ModQuantizer - modulatable quantizer
  • Changed the input level control for all note quantizers to be an input range control with a value to be set in semitones. This will not affect existing patches, just the displayed value changed to something more intuitive. The default range did change from 128 semitones to 48. The range can still be negative (meaning that an up going ramp for an input would result in a down going note sequence to be generated).
  • SeqChord - chord sequencer Made a chainable chord sequencer. This one outputs four note chords for which a degree, a type an inversion and a base octave can be set.

    Which chord is to be sent to the output is selected by the active inputs, the leftmost active active input wins. Four gate outputs are available to control envelopes, for this to work properly a gate input (which determines the length of the logic output activation) has to be provided.

    For chaining the logic inputs and the signal inputs are to be connected to the respective outputs of a previous module. The last module in a chain having an activated active input will be the one sounding. The activation inputs could be controlled from a binary counter set to seq. mode, or probably a gate sequencer would work as well. The logic in-outs are the ones closest to the indicator lights.

    The chords can be transposed with the transp. control, this only works on the local chords and not on any incoming ones.

    A slew control is present to get some gliding effect on the note changes, this works on the local notes as well as on the incoming ones.

    I'm not to sure that the chords played are theoretically correct … if there even is such a thing, please inform me about any mistakes I made – I'm not too good at this and basically just googled up some stuff.
  • Slew - Slew rate limiter And a slew rate limiter, or lag, or control rate low pass filter. This actually does the same thing as the Average module, except that the knob action is reversed and that this is a control rate only module. And with that … this text became longer than the code used to implement the module.

in version 2015.11.4.0

  • This version does no longer make use of the 'bitmaps' folder that the previous version used. Instead there now is a folder 'looks' which has a sub-folder for each selectable 'look'. This version comes with two pre defined sets, the default one and the gabe one. The gabe one was made by … gabe, also known as LfoHead on the electro-music.com forum. Thanks Gabe, great job!
  • As almost all coloring is user configurable now … all color references in this document will be according to the default coloring scheme. Except that I have substituted the color green by lime (bright green) in that scheme (which it used to a long time ago as well … on a darker scheme Lime seems better visible than Green).
  • 10-03 00:09 Octangula -> Blue_Hell: is it just me, or does the knob control mode setting not make any difference?
    Ok, the modes do work on modules but not on the other knobs, like settings and main volume control strips. Fixed it for the next release – the code to do it was never present … forgotten.
  • 2015-10-09 : When a module with a MIDI assigned control is removed from a patch the MIDI connection is not deleted, resulting in GPFs … Likewise, after that got fixed … when undo is used after a module with a MIDI assigned control was deleted … that CC does not work, although it is still shown to be present with a blue border. Ok, fixed that too. Apart from that there was yet another bug, CC's were never properly unregistered, also fixed now.
  • OSC sync was not working properly anymore, it sent a message /sync where it should send /*/sync to match any listening synth, fixed that. Had not tested this apparently after I incorporated the synth name into the OSC system. Likewise, the the OscMessage module did not send a synth name (while expecting it in listen mode).
  • I was not going to make any new modules for this one … but thought a fourfold multiplier to be handy … so here it is, taking half the space of four multipliers..
    MultipleMult - Multiple multipliers
  • And another one crept in … a 16 to one mono mixer with modulation controls.
    MixMM16to1 - 16 to 1 mixer with modulation
  • Trying to make a more general look and feel settings control.
    look and feel example
    Look and feel is stored into a 'looks' sub directory of the Wren application directory, each theme goes into it's own sub folder there. These folders can contain a set of bitmap files and a configuration file 'looks.ini'. On loading a a look and feel preset the bitmaps will be loaded from the selected folder and set as the application bitmaps. The file 'looks.ini' is then read and any settings in there will override the settings as read from the normal ini file, including the visual theme specified there. You can still override some settings after loading a preset, and these will be stored in the normal ini file. The 'looks.ini' file will be overwritten by Wren only when explicitly requested (by using the 'Save as preset ...' button). For example:
    look and feel example
    The following items can be customized (and can be stored in look and feel presets):
    • Each module has a bitmap associated with it, when a bitmap file is found in the looks folder that bitmap will be used. Bitmaps have to be named like <ModuleName>.bmp for this to work. The bitmaps should have a size of 21 by 21 pixels. I will supply example files as part of a default looks set.
    • Some bitmaps used by the modules can be overriden, this concerns the following items (I will supply example files as part of the default looks set):
      • skin_connector_audio_in.bmp
      • skin_connector_audio_out.bmp
      • skin_connector_control_in.bmp
      • skin_connector_control_logic_in.bmp
      • skin_connector_control_logic_out.bmp
      • skin_connector_control_out.bmp
      • skin_connector_logic_in.bmp
      • skin_connector_logic_out.bmp
      • skin_down.bmp
      • skin_env_attack_exp.bmp
      • skin_env_attack_lin.bmp
      • skin_env_attack_log.bmp
      • skin_env_attack_s.bmp
      • skin_env_release_exp.bmp
      • skin_env_release_lin.bmp
      • skin_env_release_log.bmp
      • skin_env_release_s.bmp
      • skin_gate_gate.bmp
      • skin_gate_off.bmp
      • skin_gate_trig.bmp
      • skin_indicator_active.bmp
      • skin_indicator_high_active.bmp
      • skin_indicator_high_inactive.bmp
      • skin_indicator_inactive.bmp
      • skin_indicator_low_active.bmp
      • skin_indicator_low_inactive.bmp
      • skin_indicator_mid_active.bmp
      • skin_indicator_midinactive.bmp
      • skin_knob.bmp
      • skin_module.bmp
      • skin_mute_active.bmp
      • skin_mute_muted.bmp
      • skin_mute_passtrough.bmp
      • skin_no_knob.bmp
      • skin_shape_random.bmp
      • skin_shape_random_square.bmp
      • skin_shape_saw.bmp
      • skin_shape_sine.bmp
      • skin_shape_square.bmp
      • skin_shape_tri.bmp
      • skin_signaltype_inverted.bmp
      • skin_signaltype_negative.bmp
      • skin_signaltype_negative_inverted.bmp
      • skin_signaltype_normal.bmp
      • skin_signaltype_positive.bmp
      • skin_signaltype_positive_inverted.bmp
      • skin_small_knob.bmp
      • skin_solo_off.bmp
      • skin_solo_on.bmp
      • skin_up.bmp
      These bitmaps will have to be 'approriately sized', except for skin_module which will be stretched as needed.
    • The following patch related colors can be changed from Wren directly:
      • Editor background color
      • Module color
      • Connector border color
      • Selector color
      • Selector border color
      • Selector border color single
      • Display color
      • Display border color
      • Knob MIDI color
      • Knob focus color
      • Knob MIDI and focus color
      • Viewer color
      • Viewer border color
      • Viewer line color
      • Viewer fill color
      • Indicatorbar peak color
      • Indicatorbar valey color
      • Audiorate color
      • Controlrate color
      • ControlrateLogic color
      • Logic color
      • Unconnected wire color
      • Wire highlight color
      • Module group I/O color
      • Module group OSC color
      • Module group LFO color
      • Module group Env color
      • Module group Filter color
      • Module group Switch color
      • Module group Mix color
      • Module group Control color
      • Module group Note color
      • Module group Math color
      • Module group Logic color
      • Module group Seq color
      • Module group FX color
      • Module group Delay color
      • Module group Utility color
    • A visual theme can be selected, this mostly is for the non editor related visuals. Currently user made visual themes are not supported, it seems to be possible to arrange for that though. Anyway, several themes are built in.

      Guess it will survive the coming winter with all this fresh paint :-)

      in version 2015.10.2.0

      • A multi compare module, after an idea I found here. Added individual outputs in addition to the bus outs, added random and clear buttons as well. Moved the module from the Sequencer to the Logic page … not sure … but hey, there is a module search function :-)
        MultiCompare - multi compare module
      • Moved the Pad module to the Utility page and added a new Knobs4 module there too – featuring larger knobs and memo fields to be able to give some information about what the knobs do. Added a switches module as well, same idea. And buttons, for momentary switches, with indicators lighting up when a pulse starts. The button out's are active for 1 ms, the lights for 125 ms.
        Knobs4 - four knobs Switches4 - four switches Buttons4 - four buttons
      • Added a simple level conversion module, direct translation of input range to output range.
        LevelConverter - level converter
      • Made a new Math tab for the module selector and moved some modules over from the control tab to the new one. Added some new math modules there as well.
        Reciprocal - reciprocal module Divide - divider module Monadic - monadic function Dyadic - dyadic function

        Current monadic functions are x2, x3, x1/2, x1/3, sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), 2x, ex, 10x, log2(x), ln(x), log10(x), 2x/12 and 12 * log2(x). Invalid domain values will output zero.

        The current dyadic ones are x mod y, xy, logx(y) and atan(y/x). Invalid domain values will pass on x.

        More may follow.
      • Made the Space bar work on focused selectors (red border). It will select the next value or when out of values the first one. This also works for momentary switches (buttons, each hit on the Space bar will pulse it then).
      • Fixed the lockout mechanism which must prevent module's real time execution during memory allocation and de-allocation. This should cure some issues like access violations or Wren stopping audio generation or knobs stopping to be responsive, stuff like that, which would still happen under some conditions with modules like the filter banks. The mechanism used only gives just a smidgen of performance loss (full fledged synchronisation degraded performance by about 20%, which made me prefer some instabilities) … I reasoned that the dirty trick I used should be ok, may it be so :-)

        As a consequence: Starting a second instance of Wren does not stop audio for the first instance anymore, as it occasionally would do.

        As a consequence: It should no longer be needed to restart Wren after a sample rate change was made in the Settings Screen F3.

        As a consequence : It should no longer be needed to stop audio generation before a sample rate change is being made in the Settings Screen F3, the change restrictions that were present have been removed. Wren needs to still stop and restart audio to make the new sample rate work, but it can automate that now.

        As a consequence : Removed the option to not use PortAudio when it is available from the Settings Screen F3. This option can still be set from the Wren ini file though (set 'UsePortAudio' to 0 (zero) there).
      • Changed the way output to input links are followed in a compiled patch. These are now traversed from the modules themselves instead of from the synth patch. Not only is this a tad more efficient, but once the compiled modules get properly sorted as well, signals will have less delay trough the patch. Right the modules were properly sorted already – great :-)

        Module execution order is top to bottom and left to right. Which means that signal flows from top to bottom and from left to right should have zero samples of delay, and reverse direction links should have one sample of delay.

        The lost feature is that in debug mode wire performance is no longer profiled separately, it has become part of the module execution time. But then again, there is no profiling support for release versions of the code.

        Also feedback behavior in existing patches may have changed.
      • Changed the drawing order for the graphs, the leftmost output (channel 1 L) is now drawn topmost.
      • Made help file generation automatic at program startup. The code will check the version information and new files will only be generated when needed. This also means that the image cache used for module previews in the module selector should always be up to date now. The popup asking for confirmation on writing out the help has been removed. It also means that starting up a new Wren version for the first time will generate some 'nervous window stuff'. I have no solution for that yet – in order to generate a proper module image the module has to be made visible, or some controls will not be painted correctly.
      • Forgot to actually update the patch version to 4 in both source code and for this page (should have done so for version 2015.8.21.0), fixed it now.
      • Moved some controls and indicators from the I/O level pane to the top control pane, and made the module selector resizable with a splitter bar.
        control strip
        When the buttons do not fit the width of the page in the module selector a left and a right scroll button are added.

        Also made a toggle on the visibility of the top pane as a whole, accessible through the view menu and using Ctrl+T as a keyboard shortcut. Currently the module finder has to be disabled when the top pane is not visible – could maybe add a modal dialog for that later on.

        So can do this now:
        minimal user interface
        for instance.
      • Made the CPU overload indicator larger.
      • Fixed some minor issues with displaying the file render status. Audio generation will be restarted now as well when rendering was stopped (when it was on before rendering was started). Changed the render indicator to be a slow green flashing light.
      • Added a context menu for the patch editor. It can be used to insert new modules cut, copy and paste modules etc.
      • Changed the default sample rate to 88k2, that's just the 'out of the box setting', an ini file present will override this.
      • Fixed the file history (menu File/Reopen) such that the files are actually listed according to when they were last opened now.
      • Fixed the issues with menu shortcut keys, the original issue text was:

        2014-12-13 : Ctrl+A in the Debug Screen F5 selects all modules in the editor … and more keyboard shortcuts go wrong there … like Ctrl+C copies a patch, not handy.

        The solution also fixes the issue with the Del key not working in the popup editor for displays. The module title editor had the same issues, fixed those as well.
      • Changed the way the Enter key works in display editors. Some editors are multi-line and those will need the Enter key as part of the text to be edited but most are single-line, and will accept a plain Enter now for confirming the edit and closing the popup (as it already did for the display title editor).
      • Re-grouped the items in the file menu, changed some other menu's as well.
      • Added a toggle for sound generation, Ctrl+D. This is accessible from the action menu too. When active all sound outputs are muted but the patch will stay in a running state.
      • Added a toggle for lights updating, Ctrl+L. This is accessible from the action menu too. When active the indicator lights on modules are disabled. This can save a little processing time, like 15% or so. Note that the lights update rate can be changed too from the Settings Screen F3. This is not very useful when PortAudio is being used, as in that case the lights update process runs not on the same thread as audio processing. It would help a bit for legacy mode though.
        Also improved the speed at which the lights are handled – this used to work with formatted strings that needed to be made and parsed, now just passing around pointers to records with t the detail information. Also pre parsed the names of the lights for faster comparison during the update process. Did the same for all other data gathered for the editor from the synth, but lights are processed most often. This could maybe be sped up more by letting the synth broadcast changes, but it would need to maintain some state then and a synchronisation queue would be needed. Prolly not worth the trouble.
      • Added 'panic' control, Ctrl+P. This will stop all pending notes from MIDI inputs and from the MIDI player. This is accessible from the action menu too. MIDI input modules will listen to a MIDI AllNotesOff command as well.
      • Made it so that when a knob or slider is locked that a rnd or clr button will leave it as is.
      • There was a kludge used for the GVerb module to make the spread control work more or less properly. That kludge was based on the lights timer, so when the lights are disabled the kludge does not work anymore. As a kludge is still needed I replaced it with another one, added a timer to the TModGVerb code … at least stuff will not be broken by accident anymore that way … The thing is that the RoomSize can not be properly modulated in the GVerb code, and I still want to be able to do that. But the room size must be set before the spread can be correctly calculated. The timer will cause a little delay after patch reset to give some time for the room size to be set up, it will then recreate the reverb.

        Also for this module, I've removed some needless calculations for parameters that were not changed.
      • Fixed menu shortcuts for automatically generated menus, these would jump from '9' to 'K' instead of 'A'.
      • Added shortcuts Alt+1 .. Alt+4 to show 1 .. 4 I/O level strips.
      • Some selectors have only one value to choose from, and thes effectively act as momentary buttons (for reset or randomization mostly) I've given those a white border instead of the selectors' default yellow one.
      • For PortAudio mode started using the PortAudio CPU usage indication, which is more accurate than what was used before (and still is in Legacy mode). The CPU usage shown will be lower, but it will run out of real–time now at 100%.
      • Added support for loading bitmaps from files, this needs a bitmaps sub folder of the folder the Wren executable file is in. It also needs properly named and sized bitmap (bmp) files – going for 21 x 21 pixels.
      • Changed the default for the bread and butter mixers to dB mode instead of linear.
      • Fixed the spacing in the module selector.
      • Toying a bit with skinning, for instance, with a couple of custom bitmaps in the module selector (some more examples) :
        themes preview
        It works reliable now, so theming will be available for the next release. When needed it can be disabled from the ini file by setting UseThemes to zero – by default theming is on though, and there is no way to change this from the software itself. When theming is disabled the default Windows theme is used, just like in previous versions of Wren. When theming is disabled it is still possible to load your own user glyphs for the module selector.
      • Changed the default looks to be 'themeless' so it will look mostly like previous versions, a user can select a theme then to fit her needs. I did have to change some things in order to get things compatible with theming support. I will add a zip file to this web page with a couple of bitmaps to enhance the looks a bit. For now I'll not add any new module glyphs, that needs a bit more work, but these can easily be added later on. The bitmaps will be included in the main zip download as well.
      • Added a file opener for Scala files which shows the contents of the file selected to ease the selection a bit (the first couple of lines having some useful comment usually). You can enter a wildcard mask to zoom in on files as well. This is all a bit Windows 3 like, but that was the plan with windows 8 eh :-) Anyway, it works.
        scala preview
        The actual looks of this dialog are determined by the selected theme.
        Changed the code a bit such that file open dialogs from the patch will try to go to the directory that the currently used file is in.

      in version 2015.9.2.0

      • And the filter bank is finally finished :-)

        I had planned to realize this filter using Fourier transforms, but it ended up using State Variable Filters … up to 102 of them when the steepness is set to 6. It takes some amount of calculation time then, but steepness can be set lower and it is not too bad actually. Steepness controls the number of filters put in series 1 to 6 can be selected, where each step is a 12 dB filter and so amounts to 6 dB / Octave of slope for the bandpass ones.

        I've scaled the range for the Q control a bit so it's more or less usable over the full range – it depends a little still on the selected steepness. Also divided the effective internal filter Q by the number of filters cascaded, which tames the silly amplitudes a bit, not perfect but it's workable. At high Q settings and a large steepness it will do some ugly stuff still.

        The low side filter can be set to either low pass (shelving) or to bandpass and the high side filter can be set to high pass (shelving) or bandpass. The in between ones are bandpass always. The Q control can be used to add in some resonance. Added level modulation for each filter chain, and added FM control to be able to sweep the filter as a whole, but note that there is an upper limit for the frequency that can be used for a state variable filter. So for high modulations the high end frequencies may turn out to be lower than expected, and you might want to set some faders to zero there.

        Decided to make two filter types, one having a half octave (tritone) filter spacing, and the other a third-octave (major third) spacing. Both have the same amount of filter bands and so the second type has a reduced frequency range.

        TritoneBank - tritone filter ThirdBank - third filter

        And while we are at it … let's make a couple of splitters too. Added clip indicators to these.

        TritoneSplitter - tritone splitter ThirdSplitter - third splitter

        And … a simple modal thingie would be cool too :-) Added some random buttons to this one to help search for timbres, it should probably have presets that can be saved and reloaded. Come to think of it, I could make a general purpose presets mechanism for modules making use of the existing parameter paste mechanism. And then control it trough the module popup menu.

        Modal - modal filter
      • Just did that, added a presets mechanism for any selected set of modules or for the patch as a whole. Module presets can be used by selecting the modules to save as a preset, then right clicking on any of the selected modules, and then use 'Save as preset'. Patch presets can be saved from the file menu. On loading from a preset the selection will have to match the selection that was used on saving the preset, or else there will be a structure mismatch. So this probably is most useful for the patch as a whole or for single modules.

        The file format used for presets is exactly the same as the one for patches, but they will by default be saved with a '.preset' file extension. So they can always be loaded 'as a patch' (for seeing the structure of it for instance).

        Loading from a preset will only change the knob settings of the selection and there will be no patch recompilation, and so the patch will just keep playing using the new settings.

        When there is a structural mismatch on pasting of parameters there will be a warning generated now. These warnings can be disabled from the Settings Screen F3.
      • Made the search function to operate on the module selector as well. Non–matching modules will be hidden from the selector. and when a page becomes empty this way the page will be hidden too.

        This feature can be disabled from the Settings Screen F3, and also made it possible to disable patch searches from there. When both options are disabled the 'find' control and the menu item for it will be disabled.

        Pressing Esc while the keyboard focus is on the search box will clear the search phrase.
      • Rate Smartness (where modules can change execution speed based upon the actually connected signals) is now indicated with [RS] in the module popup description shown from the module selector.

      in version 2015.8.26.0

      • Added a new module type, a 16 step clocked delay (analog shift register). It is rate smart and it has the option to clock it at audio or control rate with an internal clock (fast mode) instead of from the clock input (clocked mode). When the module is operating at audio rates the fast mode will be audio rate, control rate otherwise. Just connect an audio rate signal to any input to make the module operate at audio rates. This one could be used not only as a bucket brigade like delay, but in fast mode you could implement your own FIR filters with it when used in combination with the 16 input mixer for instance.
        ClockedDelay16 - Clocked delay
      • Made a NoteQuantizer module. It quantize it's input value to the note nearest to one selected by the note selectors. When the highest and lowest nearest are equidistant it will use the higher one, and when no notes are activated it will pass the input value unchanged. Added an input conditioning knob to it to attenuate the incoming signal, or to invert it (attenuverter).
        NoteQuantizer - Note quantizer
      • Made a lookup table module with 16 sliders for the values. A select input selects which fader will be output, and there is a cross fade option to be able to output in-between values. This one is to be found on the sequencer tab, as it can be used for sequencing when driven with a saw shaped input signal (range [ 0, 1]).
        LUT - Lookup table
      • Made the Scala module working, copied the details about it over to a separate page.
        Scala - Scala scaling module

        It translates note information into scaled note information according to the Scala keyboard mapping and scale files loaded. The input is supposed to be be connected to anything that generates note information, like a sequencer or a MIDI note in module, etc. This information is first translated into MIDI key numbers internally, then the Scala algorithm is applied, then the output value is translated back to an internal note value again (128 notes / unit).

        You can get scales and keyboard mappings from http://www.huygens-fokker.org/scala/ but also there is the Scala program itself on that site which can make such files to your own liking .. it will also tell you how to hand-craft such files.
      • Made an inconvenient choice for the signal levels of the 'rec' buttons in the granulators and had to invert them. This means that on patch reload granulator recording will be inverted from how it was aved with the previous Wren version. Sorry about that …
      • I seem to have over 150,000 lines of code now
        smiley - eek!
        or 150 KLOC, sooo … there should be about 1500 – 7500 bugs … or 'code defects' as they call them … when I perform as 'good' as the 'code industry'. Or around 75 when I'm as good as µsoft … or ZERO when it is as good as space shuttle code. (see here for a rationale of this).
      • Fixed a bug causing Wren to refuse to stop under certain conditions. It would also not allow the Delphi environment to be shut down after Wren had run in debug mode. Forgot to call the inherited handler in a Notification function ... or forgot ... it was omitted in some old code that used to work long ago without that call (TKnobsWormPanel.Notification). I should have disabled the Friemels module as it does nothing usuful anyway.
      • The lookup tables were about twice as large as I had meant them to be, halved them.
      • Poetry generator, XYScope, Vocoder, Convoder and Filterbank had a memory leaks, fixed those.
      • The WaveWiper had its dezipper spec in the constructor instead of in SetDefaults.

      in version 2015.8.21.0

      • Poetry - Poetry module Added a 'Poetry' generator, modeled after an idea found in a Phd thesis by Johnathan Mackenzie found here. It finds seed patterns in a buffer starting at some random buffer position, and it will get it's next output from the value following the found seed. Then it will repeat this strategy, producing variations on a read in pattern as it moves along. New values can be clocked into the buffer and the search algorithm is triggered from a separate input. This is very similar to a hidden Markov model.

        This module is primarily meant to generate variations on control signal sequences, but the module is rate smart and will switch to audio speed when needed. As is, the history may be too small though for audio processing (and the search algorithm is probably too slow to allow for substantially more history). Anyway, I like it for control signals.
      • Delay8 - Eight tap delay Added an eight tap delay where each delay output can be individually modulated. Just like the regular delay module there is a fixed output having the maximum delay with no time modulation, and the delay time can be set from 10 µs to 5 minutes - in three separate ranges. The delay modulation inputs modulate between zero delay and max delay for input values from 0 to 1.
      • Added OSC support. Wren can be either an OSC transmitter or an OSC receiver. See the FAQ for more info on this and about how to set up OSC and about what OSC messages are implemented.

        In the current OSC implementation there can only be one listener in a patch for any specific address. The first listening entity seeing the message will disable it for other potential listeners. There can however be multiple transmitters for the same address. This is a feature of the OSC module I've used, and I may change this for a future version – it does not seem to be a serious limitation currently as further signal propagation can be done on the wire level in the patch.
      • Sync - OSC sync module Added a sync module which can send sync signals from one Wren instance to another. Or alternatively external OSC enabled software could make use of this. This module sends and listens to OSC /<synthname>/sync messages. See the FAQ for more info on OSC messages.

        The sync rate must be lower than a quarter of the control rate (currently amounting to the sample rate divided by 32), or else it will not work properly. A practical maximum working for all sample rates would be 1 kHz.
      • OscMessage - OSC message module Added an OscMessage module which can send or receive arbitrary float values over OSC using a user defined address. When the current Wren instance is an OSC transmitter it will send the value present on the blue output when the trigger input goes from low to high, this value will be set as the output value too then. When Wren is set to be an OSC receiver incoming OSC messages matching the set address and having a float value as their first argument will set the module output value (it will still copy the input value to the output as well on a trigger action).

        Messages may be sent with more than one parameter, only the first parameter will be used, and only when it's type is 'f' (float).
      • RndGranulator - random granulator Granulator - granulator SimpleGranulator - simple granulator Working on Granulator modules. These are all based upon sample storage in a delay line (hence, the module can be found in the delay section). The length of the line can be set up to five minutes. A maximum of 128 grains has been set currently, which seems to be about what the system can do (although the maximum actually obtainable in real time may be lower, depending on settings).

        There is control for the grain playback speed (dly mod), the grain inter-onset time, the grain duration, the grain volume and grains can be panned as well. There is a record control to be able to stop recording into the delay line, when it is off the delay line is being looped. The input left of the record control morphs between recording and looping for dynamic record control.

        For the first type the inter-onset time, the duration, the volume and the panning can be randomized. Not quite sure yet on how parameter modulation should work. Once the grain starts all the parameters are set, and they will not change during the grain's lifetime.

        Added a second type of granulator which does not have the parameter randomization, instead this should be controlled trough the modulation inputs. It looks exactly the same but the modulations work in a different way.

        Added an input on both versions to control the grain start point within the storage loop (this was just a random point before). Also upped the maximum grain count to 256. This can easily get the CPU on it's knees for certain settings, but for other settings it's nice to be able to have a higher grain count than previously possible.

        Renamed Granulator into RndGranulator and SimpleGranulator into Granulator, and then added a new SimpleGranulator. For this one new grains are started from a trigger input. This one has no pan or volume control. It should be a tad more efficient CPU wise and the trigger input allows for tuned inter-grain delays.

        Current envelope shapes are Bell, Exp, RevExp, Pulse, RndBell and RndExp.
      • MixM16to1 - 16 to 1 mixer Added a new mixer type, mono, 16 inputs, a chain input and one output. Control type can be linear or dB with a couple of ranges.
      • Added S-shaped envelopes for all modules having envelope slope shape selection (including the interpolation curves on the Seq16 module). Also sped up the envelope shape calculation a tad by working out an unnecessary multiplication.
        S shaped envelope
      • Added an 'env' out to the compressor module, an envelope of the sum of the incoming signals.
      • Changed the timing for the net MIDI and OSC lights from 250 ms to 125 ms and added an OSC enabled indicator light.
      • Added a SynthName property which can be used to distinguish Wren incarnations for the purpose of OSC addressing. The synth name can optionally be shown in the title bar and it can be changed as part of the OSC settings.

        Also added an OSCAddress property to compiled modules in the synth patch, it's value is set from the module title in the patch editor. A module title starting with '@' will enable the module for OSC activities.

        Furthermore I've changed the value popups for knobs to show the OSC address fragment to use for addressing them as the first line in the popup. When the control is not automatable an exclamation mark will be shown on the first line instead.

        The OSC specific modules such as Sync and OscMessage are OSC enabled always regardless of their title.

        Working on OSC enabling all modules, and maybe the controls of the main program as well, the above is in preparation of that.

        OSC patterns starting with /*/ should be accepted by all running Wren g incarnation that do have OSC enabled.
      • Optimized Pan, XFade, MultiMult and Multiplier a bit by getting some multiplications out.
      • Changed the patch format to version 4 to allow for MIDI CC values to be bound to ValuedControls. Old patch format versions 2 and 3 should still be readable, but older Wren versions will not be able to read the new version 4 patches. Also allowed for more options to be added in the future with better backward compatibility. This change was needed to allow for CC to knob associations to be stored into the patch.
      • Added an item on the context menu for knobs, sliders and selectors for associating a MIDI CC with them. Most knobs, sliders and selectors have support for this, not all. When a a CC is associated with a control it will be painted with a blue border (when not focused, otherwise the indicator color will be red still). The associated CC will also be shown in the hint popup when it appears, and the popup menu will show the currently associated CC as well.
        Also added a 'learn' feature to quickly assign the last CC received.
        Also added a CC un-assign item to the popup menu, and and un-assign button in the MIDI CC assignment window.
      • Added a MIDI channel selector to the Settings Screen F3 to select what channel to use for the non MIDI modules (that is: passing on CC values). This can be set to listen to all MIDI channels. The MIDI modules have an independent channel selector.
      • MIDI CCs on knobs are working now, the CC directly controls the knob, which in turn will change the value in the synth – dezippering is not used on MIDI control.
      • quick channel select illustration Added a couple of quick select buttons to set the the amount of visible I/O channels more easily.
      • Some more work will be needed before general OSC will actually work, but the editor supports it now. Made code for general OSC support too now but did not test it yet. Controls are addressed by the OSC pattern /<synthname>/<modulename>/<controlname> and they want to see a float value in the range 0.0 to 1.0 for full travel. Every control that allows for MIDI automation can be OSC controlled as well. When a control is not automatable this will be shown on the control's popup menu by having an exclamation mark in the first line.
      • Made selectors focusable, they will get a red border to indicate focus (and a blue border to indicate that a MIDI CC was associated, or fuchsia when both focused and having CC control). Selectors also listen to the arrow up/down keys now when they have focus. Knobs will get a fuchsia border too now under the latter condition. Focusable controls will get focus now when the mouse cursor hovers over them regardless of the mouse wheel mode selected.
      • Output 10 of the Counter and the ChebGen module were not working, fixed now.
      • Demux module was not working, fixed.
      • Knob controls for Pan and Fade modules were incorporating the input type selected, not handy, changed that. It is a level conversion on the control input only now. This will probably break some patches … but it was just not good.
      • Fixed memory leaks.
      • Made the 'unfocus' feature work better with a 'sort of' hidden control that will get focus when knob focus gets lost. The 'use unfocus' feature is on by default, this can be changed from the Settings Screen F3. The unfocus option causes controls to loose focus when the mouse moves out.
      • Fixed sample and hold (which stopped working properly after making it rate smart).
      • Seem to have weeded out the access violations on the granulators.

      in version 2015.7.12.0

      • Added an option to use the standard module color (the color as shown when you hover over a module button in the module selector) on modules newly added to a patch. This is on by default but it can be turned off in the Settings Screen F3.
      • Added a menu item on the module popup menu for setting selected modules to their standard colors.
      • Some hints on module controls were shown where they should not be and also some were not shown that should be shown. Also there were some double hints. Sanitized the hinting stuff a bit.
      • Added a second type of folding to the wave wrapper based upon a state machine that I found here. This mode is not amplitude compensating, the output range is directly set by the mirror positions (and the modulation on that). This second mode is probably a bit more efficient to calculate. Type 1 is the old behaviour with range adjustment after the wrap operation, type 2 is the new uncompensated behaviour.

        Also added a third type. This is my take at the smrl variation as found in the link from the previous section. The wrapping is as for type 2, except that the modulation is not used to change the mirrors and the folded signal is not sent to the ouptut. What happens instead is that when the folder changes direction the modulation signal is being added to the current output signal. When the output signal goes over 1.0 it is reset to -1.0. Also the modulation works different in this case, the modulation input and knob are added for this mode instead of being multiplied.
      • ChebGen - Chebyshev polynomial module Added a Chebyshev polynomial module (ChebGen). It can be used as a wave shaper, or as a rate multiplier (harmonics generator) for sine shaped signals. It provides the order 2 … 13 polynomials. Order zero would be a constant '1' and order one is just a copy of the input signal, so these are both not provided as outputs.

        Added a tri mode to this module, which will do the frequency multiplication for triangular waves, thanks to Scott Gravenhorst (Jovianpyx) for coming up with a nice solution for the odd order cases. Below, the first image is Chebyshev mode and the second is triangular mode, both for order five (top four traces being input waves, bottom four the resulting ones from the effect):

        ChebGen module in Chebyshev mode order five for some input wave formats ChebGen module in Tri mode order five for some input wave formats

        Also see the forum post I made about this.
      • Added a couple of modes to the TerraGen module, it now has (with prod = x * y):
        off          : out := 0;
        inx          : out := x;
        iny          : out := y;
        xy           : out := prod;
        curtis_roads : out := ( x - y) * ( x - 1) * ( x + 1) * ( y - 1) * ( y + 1);
        bass         : out := Sqrt( Abs( x * x * x * x + y * y * y * y * y - x * x - y * y - x * prod * y));
        lead1        : out := ( x - x * x * x / 12 - y * y / 4 + 0.5);
        hollow_lead  : out := ( -5 * x / ( x * x + y * y + 1));
        pulsar       : out := Sqr( Sin( x * x + y * y));
        flat_growl   : out := Sqrt( Abs( ( 1 - x * x) * (( 1 - y) + y * cos( 1 / ( x * x + 0.01))))) - 1;
        atan         : out := ArcTan( 15 * prod) / HALF_PI;
        softclip     : out := prod / 1 + Abs( prod);
        third        : out := 1.5 * prod + 0.5 * prod * prod * prod;
        chebyshev2   : out := 2 * prod * prod - 1;
        chebyshev3   : out := ( 4 * prod * prod - 3) * prod;
        chebyshev4   : out := ( 8 * prod * prod - 8) * prod * prod + 1;
        chebyshev5   : out := (( 16 * prod * prod - 20) * prod * prod + 5) * prod;
        chebyshev6   : out := (( 32 * prod * prod - 48) * prod * prod + 18) * prod * prod - 1;
        chebyshev7   : out := ((( 64 * prod * prod - 112) * prod * prod + 56) * prod * prod - 7) * prod;
        Also added four and eight times up sampling modes to the TerraGen module – fast, better and best. And removed the upsampling stuff again, it was too slow. Aliasing is beautiful! … or remove it at the source side, it works OK with sines not too high in frequency.
      • Bugfix for MixQ1to1, the mode did not change when the mode setting was altered.
      • Rearranged the Settings Screen F3 a bit.

      in version 2015.6.27.0

      • Removed some clicks from the basic envelope modules EnvAR and EnvARRetrig.
      • Moved the MIDI modules to the I/O tab, but the MidiPlayer to the Seq tab.
      • Added colors on the tab buttons for the module selector, showing more or less the same color as the popup module examples from the selector.

        illustrate colors on module selector
      • Added popup hints for the settings, graphs, debug and volume control views. And made a user setting to disable that – the feature is on by default.
      • Moved all debug related settings from the settings view to the debug view.
      • Fixed a bug in the color mixer code which caused border colors for modules to be off. This was barely visible but it showed itself when I tried to color the buttons on the module selector.
      • Removed the design notes from the designer window (FrmStore.pas) and stored the text into a file module_design_hints.txt which will be distributed with source code releases.
      • Suppressed some of the Delphi RTTI by using
        {$IFNDEF DEGUG}
          {$WEAKLINKRTTI ON}
        in the main project file. This strips off about 13% from the exe size.

      in version 2015.6.21.0

      • Another error in displaying the envelope curves … the range settings were all taken from the attack range – fixed now.
      • Added some glyphs for a bunch of new modules, it got all a bit confusing with the copied ones.
      • Updated some help text, some new modules still had text copied from the modules they were copied from.
      • Fixed the tab order for some new modules.
      • Decreased the spacing between module buttons on the module selector a bit to get room for more module types. Resized all module glyphs to 20×20 px. to make that fit.
      • Changed the default font for the module title to Corbel 8 pt bold, seems lighter but more readable than the previous font used. Only thing is that it has 'oldstyle' numerals, that is lower case. When this font is not available (as in Windows XP apparently) the module titles will use the old font (Small Fonts 7 pt bold). But read on …
      • Made user selectable fonts for module titles and module text. It is probably best to keep using Small Fonts for the module text, as some of the text was measured out with that font, but one could still change the color.

      in version 2015.6.19.0

      • An instant crash was reported by a user, no clues yet.

        Inspecting the code I did find a bug in the audio handling. When it ever happens that there is no compiled patch and the audio stream runs, the audio I/O processing will write out of the array bounds of the audio out buffer … seems likely to be that … on a slower system audio I/O may run before the patch got compiled. Also it would be worse with largish audio buffers (seeing that user's buffer size is 4096, using 512 or so here). Fixed that issue.

        It fixed the problem too.

      in version 2015.6.18.0

      • Made a WaveWiper module after a schematic made by PHOBoS, which he in turn based on a Voltage Splitter idea published by Jim Patchell. Not sure if it does exactly the same thing, but it is quite a nice wave shaper I think. This module is rate smart, it runs at control rate when all inputs are control rate signals, at audio rate otherwise.
        WaveWiper - wave wiper module
        InSig1   := FInputs[ i_in1  ];
        InSig2   := FInputs[ i_in2  ];
        BreakSig := FInputs[ i_break];
        Mute     := SignalToMute( FInputs[ i_mute]);
        FOutPuts[ o_out1] := ( Max( Insig1, BreakSig) + Min( InSig2, BreakSig) - BreakSig) * Mute;
        FOutPuts[ o_out2] := ( Max( Insig2, BreakSig) + Min( Insig1, BreakSig) - BreakSig) * Mute;
        With a sqare and a triangle input modulated (on the break input) by a sine wave:

        wave wiper example output
      • And while wave warping .. made a WaveWrapper module too. This one will mirror the input signal in a user set low and high bound limit. The limits can be modulated by the mod input. This module is rate smart.
        WaveWrapper - wave wrrapper module
        Modulation  := Normalize( FInputs[ i_mod] * FInputs[ i_modamt]);         // Modulation amount
        LoMirror    := FInputs[ i_lowlevel ] - Modulation;                       // Get low mirror and subtract modulation
        MirrorDelta := 2.0 * ( FInputs[ i_Highlevel] + Modulation - LoMirror);   // High mirror gets modulation added. calc mirror distance, times 2
        Mute        := SignalToMute( FInputs[ i_mute]);                          // Get Mute multiplier
        if Abs( MirrorDelta) < 1e-6                                              // When mirrors are too close to each other
        then FOutputs[ o_out] := 0                                               // make an exception ...
        else begin
          Amp    := 4.0 / MirrorDelta;                                           // Amplitude reduction factor due to wrapping - times two
          Signal := MathFloatMod( FInputs[ i_in] + LoMirror, MirrorDelta);       // Lift signal by LoMirror, and take signal modulo 2 * Delta
          if Signal > 0.5 * MirrorDelta                                          // Reflect bit above Delta back
          then Signal := MirrorDelta - Signal;
          FOutputs[ o_out] := Normalize(( Amp * Signal - 1.0) * Mute);           // Bring signal into -1, 1 range and apply Mute signal
        With a sine wave input (range -1, 1), the low level set to about -0.6 and the high level to about 0.4:

        wave wrapper example output
      • Made a logistic map module. This one is rate smart, driven by an input clock signal. Not sure yet what the definitive form will be. R values below three and different start values seem not to interesting, so I may remove those. And the cross fade works good only when the clock rate does not change .. so I may change this into an oscillator module.
        LogisticMap - logistic map module
      • A new LFO module based on strange attractors, a Lorenz type and a Rössler type. Both the Lorenz and Rössler systems are 3D, so I made three outputs for both types.

        Made an audio rate version too and had some trouble to get the calculations stable for that. It needed quite a bit of over sampling to get it right (or actually the time step must be smaller than some critical value). For a sample rate of 44k1 12 times over sampling for Rössler (time step ⪅ 0.08), 15 times for Lorenz (time step ⪅ 0.02) seem to do the trick). For higher sample rates the amount of over sampling could be set lower but it betters the sound quality too. This may have to be adjusted later.
        AttractorLfo - attractor LFO module
        Attractor - attractor module
        Maybe these should get some means to set initial conditions, but otoh they seem to visit a lot of places already.
      • » Decoupled the connector color from it's signal type. In the designer the signal type should be set now and the default wire color will follow that. Also made a separate color lookup for painting connectors and wires. User selected cable colors are possible now; connector colors still reflect the signal type.

        » Note : The patch version got changed to 3. The patch reader will still read version 2 patches, and previous Wren versions can read type 3 patches as well, just ignoring the wire colors in it.
      • Changed the default wire color Lime (for control rate logic signals) into Green, Lime was not very visible on most module colors.
      • Moved Quantizer to the Note tab and made it a control rate module. Also the Scala and the TransInv modules are control rate now.
      • » Made rate smart modules. These execute at control rate normally unless one of their inputs gets connected to an audio rate output, they switch to audio rate processing then.

        » rate smart modules are: Inverter, Adder, Multiplier, Scaler, Ratio, Rotator, Rectifier, MinMax, MultiMult, Median, HardClip, Not, Gate, Divider, DFlipFlop, RSFlipFlop, Counter, ADC, DAC, Compare, LogicSelector, ProgDivider, XFade, Pan, MixM4to1, MixS2to1, MixTto1, MixQ1to1, SampleAnsHold, TrackAndHold, Switch2to1, MultiSandH, Mux, Demux, DigiMux, DigiDemux, TerraGen, Average, GateSeq, Seq16, SeqSeq, SeqStep, SeqClockStep, EuclideanRhythm, PhaseDetect and ClockedDelay.

        Changed the built–in module help to indicate rate smart Modules and what rate smart–ness does.
      • Removed a tab control level, all screens are on the same tab control now, giving a bit more screen space for the settings, graphs and debug screens.
      • Made a couple of new checkboxes in the Settings Screen F3 to control what appears in the title bar.
      • Changed the PortAudio handler in FrmMain to combine the loops for input and for output into one.
      • Sped up the Normalize function considerably by not using the Delphi internal TDoubleHelper methods. Requested it to be inlined, but Delphi seems to mostly not do that. The SignalToMute function basically uses the same code as Normalize, changed that one too.
      • FreeVerb internally works with Singles, not with Doubles (for floats) as the rest of the synth does. The standard Normalization routine would not always properly deal with that – changed the value for the smallest acceptable number to 1e-20 (-400 dB).
      • Local copy of Normalize routine in GVerb module fixed too now.
      • Error in drawing the shapes for EnvAHD (and likely EnvADSR as well). I had changed the way the knobs work and how their values are calculated, but this was not reflected in the drawing of the envelope shapes, fixed now.

      in version 2015.5.31.0

      • NOTE: The memory management was changed, the borlndmm.dll is no longer needed – and it is not available for download anymore. This needed some code changes here and there and I may not have touched all affected places, please report bugs on the forum, will fix ASAP.
      • Added a debugging aid — Find small values — to help find possible calculation bottlenecks in a patch. This can be accessed from the action menu or from the Debug Screen F5. This feature will search for values that are either denormal or are in the range (-1e-50 … 0) or (0 … 1e-50), small values being not zero. Hit F10 to highlight the modules having such values on their inputs / outputs or as internal signals. In the Debug Screen F5 a listing will be made of the found modules and the pin / knob names found (Name [Title] [inputs] [outputs]), knobs are listed as inputs. For compiled versions that have profiling support (which the regular releases do not have) the small value finder is part of the profile action.
      • Changed ranges a bit for knobs in dB modes and for Mute buttons – these are off now when their value is <= -140dB. Changed the dezipper algorithm in the same way, values <= -140 dB result in zero.
      • Made an option to allow for undo after a patch was saved, it is off by default. Likewise added an option for undo after load.
      • Tab order of form and module elements sorted – some elements do not properly show focus, that needs a fix too.
      • Cleaned out the source code a bit, removed unused units from the project, unused code from units, etc.
      • Experimented with allocating memory in large chunks. This was not really a good idea; having many smallish chunks performs better. Anyway, that idea is tested now.
      • Added user definable scales for the SeqRandom module, these will be loaded from a file wren.scale which must be in the same folder as the Wren executable file. When this file does not exist Wren will create it, after that you can edit it with a text editor (like Notepad for instance) and Wren will not touch it anymore.

        For example:
        scale definitions text scale definitions view
        A Line like
        "-", []
        (which is a dash for the scale name and no notes in the scale) adds a separator to the selector's popup menu.
        This unfortunately will likely break existing patches, in that for the SeqRandom a different scale will be loaded than was saved into the patch. Also this will make patch sharing a bit fuzzy as there may be a different set of scales in effect — but then again, such already was the case for wave players and Talkie files as well.
      • Some designer changes: added a 'DynamicStepCount' property for TKnobsValuedControl and for TKnobsXYControl. When this field is set to true (by default it is false) and the value for the control goes over StepCount - 1 StepCount is fixed to value + 1. This was needed to make the user definable scales work properly. This is also used for ModTalkie to allow it to have more than 32 voice banks. Also added a design time field '_DesignerRemarks' on TKnobsValuedControl and TKnobsXYControl, this is just a comment field, it is not used at run–time.
      • Added Dyads and Triads to the default scales for SeqRandom. Should make it easier to program scale modulations using chained SeqRandom modules.
      • Made Picture and Docs properties for modules, so that information is no longer in TImage / TMemo components in the designer, which cleared stuff up a bit there.
      • Added a help item to the module popup menu showing the help text in a message box instead of in the web browser.
      • Edited help texts a bit to get the greatest nonsense out.
      • Had some inputs exchanged on the audio rate square OSCs – PWM was not working – fixed now.
      • Changed the memory manager – this revealed some allocation and de-allocation issues, Like freeing something in the Median module that was also freed by the system. Some more things like that … anyway, trying to get rid of the memory manager DLL, reasoned that it would not be needed. Ah, and in allocating a new synth patch as well.
      • Changed the knob ranges for the SeqRandom module slightly, to be able to better set fractional values.
      • Freq input was not found on Pluck module, stopping execution of the user interface. Added the forgotten freq input. Also added some exception trapping to make connection errors issue a log item only and to not prevent the system from running the patch. The wires will still be there in the editor (and they will be saved on a patch save), it is the compiled patch that does not know of the input, and so the connection will not be made.
      • Made the program write logs to a log file (wren.log in the application directory). This feature will be always on at program start, but it can be set disabled from the Settings Screen F3, which will cause the feature to be turned off once the settings are loaded from the ini file. If the file exists it will be erased at program startup, so there will only be a log of the most recent program run.

        Example log:
          00:00 000 probing PortAudio DLL presence, looking for "portaudio.dll"
          00:00 319 PortAudio DLL found
          00:00 321 probing FFTW DLL presence, looking for "libfftw3-3.dll"
          2015-05-30 12:36:43:622 compiled synth patch
          2015-05-30 12:36:43:656 starting  PA [api: "Windows DirectSound", in: "ADAT 1 (1+2) (R ...
          2015-05-30 12:36:43:684 PortAudio was started
      • Made graphs to be invisible by default, it can be enabled in the Settings Screen F3. Changed the drawing of the main PageControl a bit so it does not show the nearly invisible tabs anymore (there were a couple of pixels in the top left).
      • Removed the About Screen – program information can now be found on the Settings Screen F3. The About button there and the About item in the Help menu now go to this site.
      • Bugfix on Pluck module, on FM modulation it could end up with a negative array index, causing a program crash.

      in version 2015.5.12.0

      • Bugfix for crash at 00801B75 ... code tried to read data from a synth patch that did not exist.

      in version 2015.5.10.0

      • Changed the knob ranges for a lot of modulation attenuators … old patches will need some work … especially FM control for oscillators. The new ranges make it easier to set fractional values, like 0.5 etc. I'd probably need to change the patch format so that it stores values and not knob positions, so that on an internal change it could find the closest value. I had that before, but it was messy, so don't know.
      • Made a RangeConverter module, or a linear mapper. For each input the selected input range is mapped onto the range set by the low and high values knobs. The input ranges are chosen to map the standard LFO output ranges.

        range converter module

      • Added a four channel mixer MixQ1to1.

        quad 1 to 1 mixer

      • Changed the layout a bit for MixM4to1 to make it clearer what are mix inpits and what are level control inputs — hopefully.

        4 to 1 mixer

      • Added a new tab on the module selector – 'Note' – and moved some modules into that from the Control tab, it was getting a bit crowdy there.
      • Fixed an issue with knobs: with a high opacity setting the red rectangle indicating selection would not be visible.
      • Changed knob painting a little to remove the faint rectangle it would always show.
      • Changed VU meter peak and valey indicator fall-off rates to be more consistent over various sample rates, buffer sizes and channel counts.
      • User set lights update rate was not restored after program restart – so it used a fixed value of 43 ms … until the setting would be manually changed — fixed now.
      • Added a new connector and wire color, Lime (bright green), to indicate control rate logic signals. Changed several modules for that.
      • New wave types for LFO's — 'Random Square' and 'Random'. The 'Random' type is white noise.

        lfo random pulses lfo random wave

      • Fixed bug in template support – loading or saving a template would change the internally stored filename of the patch so that a later save action would overwrite the template and not the patch. Also made the filename visible again in the window title. Filename and patchname can be different …
      • Changed the help for the Pulses module to explain why it does not always listen to the frequency setting, also changed the default mode for it to not be 'Async'.
      • PinkFilter had denormals – fixed now.
      • The denormal preventer itself would create denormal exceptions during debugging when the value passed to it was a denormal already, changed the code to first check that condition (in debug mode denormal checking is on to be able to find such issues) – fixed now.
      • Added signal normalization to all mixer outputs.
      • Changed sensitivity of PM input for ModResonator to be 32 times less sensitive. With the previous settings subtle modulations were impossible.
      • Added patch changed warning on loading a new patch or a template. This can be disabled in the Settings Screen F3 – 'on load warn for patch changed'.
      • Starting to add un-attenuated frequency control inputs to modules, sofar Osc, Square, Pluck, OscTrig, SquareTrig, SVF and HrastSVF. These will just be added to the value set by the frequency control knob(s).
      • Changed the detection for unconnected modules. When a module has no connectors it is regarded to be connected. When it has no outputs it is regarded to be connected when an input is connected. Finally when it has outputs it is regarded to be connected only when an an output is connected.
      • Added pass-trough mode to the mute buttons of the FreeVerb and GVerb modules.
      • Changed the order of items in the module popup-menu to make it less likely to delete selected modules by accident.
      • Added input level control for Resonator module, as it is way too loud for non impulse like inputs. For single sample impulses it's fine at 0 dB.
      • Added a debug like thingie that can be turned on in the Settings Screen F3 – 'show lights time' which for each update cycle shows the amount of time spent in updating the lights in the user interface. This can help to set the 'update rate for lights' parameter – it would not make sense to set the update rate higher than what the system can handle.
      • Fixed bug in 'Recent Files' mechanism, menu items were not freed but deleted only – this led to memory corruption on patch load / save actions.
      • Added input type selector for Pan and XFade modules. Default type = [-1…1] to keep existing patches compatible.

        pannner module cross fader module

      • Added a new pitch shifter module which can be accurately tuned in semitones and cents. It has exponential pitch modulation and the delay length can be set to make a trade–off between quality and delay. This is a delay line based shifter, not an FFT based one, meaning it will have some 'clasical artifacts'.

        pitch shifter module

      • Changed some memory allocations to make sure they are atomic and non blocking on the real time thread. Eventually all should be made like that, but some were a bit easier to do …

      in version 2015.4.25.0

      • When I googled for Delphi gverb I got this page back pretty high … which prolly means I should actually make that gverb thingie (as there seems to not be a Delphi translation for it yet) … in fact I just did a code translate on it … a bit more work needed to make a module and then some testing of course. Would love to hear an FDN based reverb …

        Ok … here is a proto … its not 100% stable … when I change the max room size from 1000 m2 to 0.01 m2 in an instant it can produce invalid floats. Changing the relative (actual) room size is OK though, and added a modulation input for that for some nice effects. Also some oddities with the spread control still, on a patch recompile spread goes to zero it seems. Spread and Max room size are non-realtime controls, and will give zippery side effects.
        The issue with sudden max room size changes got fixed, there was some out of array memory addressing. The issue with with the spread control stay, and when the effect runs for a long time the signal levels will explode.

        Ok, spread control is fixed, there was an issue with initialization order. Also found a way to control the 'explosiveness', this was related to room size modulation, by changing the amplification factor in the FDN matrix thate is control, setting it to 0.45 instead of 0.5 seems to work without altering the sound too much. Also reduced the zipper effect a bit on changing the max roomsie and the spread by flushing all internal data on changes.

        Changed the maximum room size to be 6400 m2 and the maximum reverb time to 30 minutes with an amp factor of 0.46 currently — seems stable, 0.475 was unstable.

        Changed the spread control to multiply by 100 before it gets into the actual gverb code, the control still goes from 0 — 1. with 180 it would try to make negative length delay lines, I calculated 160 to be the limit, Super Collider seems to allow for a maximum of 100 … the web is not clear on this … I thought one to be pretty wide already … oh well 100 it will be.

        Added modulation inputs for damping, reverb time, tone, early level, tail level and dry level. These are all clipped into a [0,1] range and multiplied by the knob setting. So the knob sets the maximum value, the modulation can lower that only.

        Added a mode parameter to select between rounded or relatively prime length delays amd between the original and an alternate FDN matrix. See the module help for details. Differences are quite subtle, mode 1 is most edfficient computationally.

        The GVerb port is in the released Wren now and in the published source code too.

        Settled on the following ranges:
        • MaxRoomSize from 1 to 6400 m2
        • RoomSize internal minimum is 0.01 m2, Roomsize is a fraction 0 to 1 of the maximum size, but it will never go under the internal minumum. It is possible to get some glitchy results with this still, but that seems nice …
        • Spread ranges from 0 to 1 but is internally multiplied by 100.
        • Reverb time is from 5 ms to 30 minutes.
        • FDN matrix multiplication factor is set to 0.43, which has been stable here for a couple of days now under wild modulations. The alternate matrix uses 0.73.
      • Made the Average module clear it's internal state on a system reset, so that it's outputs will always start at zero after reset. This way an averager after a constant module will always make a smooth start from zero on it's LP output after a reset, and the HP output will always make an initial spike under those conditions.
      • Removed the dezipper action fom the Constant module's mute control so it can be used as an on/off switch.
      • Found some addressing bugs, where indexing constants from one module type were used in another … changed the scoping of the indexing constants so that such a thing can not happen anymore.

      in version 2015.4.12.0

      • I seem to have fukt the Vocoder, it is way too loud … hmm … I had changed some math to a complex data type … innocently enough it seems … build 103 seems to be ok still. Ok it was in the Convoder instead where I forgot to divide by the Attenuation factor needed (16777216 so there is the reason to be LOUD) … got fixed for this release.
      • Made a version check in the help menu, and also added button for it on the about tab. Using your default browser it will bring you to the Wren web site which will then do a version check based on the Wren version passed to it,
      • Added a light left of the CPU load indicator that lights up red for a couple of seconds when any internal audio buffer over or underflows occur. The CPU load can go above 100% before this will happen. And conversly it can go red when the CPU load is below 100%. Not that you'd not have heard it … but still … it may show the actual cause of odd things happening … my algorithms being too slow …
      • Changed the FreeVerb parameters (for the Reverb module) to their original settings, but as they are recalculated when the sample rate is not 44k1 the selected parameters may not be the best (i.e. not relatively prime) — this may need some more coding.

        For example see the JCRev implementation from the Synthesis Toolkit (this one sets the next available prime value for delay lengths recalculated for new sample rates). Might also want to implement JCRev as a 2nd reverb algorithm. Still need to do some tests on this … I did not like the reverb very much as it was … too much high frequeency tone like stuff is/was going on to my taste.

        Another one to look into could be gverb. Gverb also enforces the delay lengths to be prime. There are some other similar implementations around, some simpler (so less CPU cycles needed). For some examples see the Artificial Reverberation section at ccrma.stanford.edu.

        It seems better now, ensured all delay lengths to be prime, but no check was made to see if they are relatively prime, so under some conditions two might end up having the same length.
      • Changed the 2to1 switch, it actuallly is a 2to2 switch now connecting (in1,in2) to either (out1,out2) or (out2,out1) depending on the selection input.

      • Added two new modules, DigiMux and DigiDemux, for which the routing is sleected by a couple of digital selection inputs. A bit like the CMOS analog switches, except they are one-way only in Wren of course.

      • Added a zero / hold mode selector to the DigiDemux which in hold mode causes the last output value the be held when an output gets deactivated. In zero mode the output value will go to zero.

      • Added a programmable frequency divider. A low division and a high division factor can be set and with the select input it is possible to change the division rate between these two values. A step value can be set as well, the amount to add to on each increment on the division factor.

      in version 2015.4.6.0

      • The global tuning parameters were not working properly, fixed that.

      in version 2015.4.4.0

      • Removed all Jittik scripting stuff — took too long to get it stable — must be a bad idea.
      • Made peak (black) and valey (white) indicators on main VU meters. The peak indicators are dynamic, the valey indicators show the lowest value seen since last reset (to reset click on the textual representation for the min / max values). The peak and valey indicators currently are mono, i.e. the same for left and right, taking the extremes of left and right values. Changed the colors for peaks and valeys, peaks are white no and valeys black.
      • Sanitized the VU code a bit, and made the peak and valey level indicators to work per channel instead of Left / Right combined. Also added a valey value label for each pair of channels. The labels still show the extremess of the Left / Right pair.
      • Recolored the Seq16 module chain input and the out output to red make it show those run at audio rate. With the xfade feature set to one these can be used as user programmable wave forms.
      • Renamed parameter pasting into value pasting.
      • Changed the bitmaps and painting for knobs so that they will be painted better on non gray-ish backgrounds too now.

        The red box to indicate the knob being focused (and processing keyboard input) is now drawn around the knob as well, instead hiding behind it on the right and bottom sides. The up/down clickers were resized a bit to make rtoom for that.
      • MIDI modules were not working anymore, forgot to make them control mode modules after the slow / fast mode changes in the previous release — fixed now.
      • Changed internal scaling for envelope times to not use a time in seconds anymore but a a range [0,1] which makes it easier to have properly working time modulations. Some existing patches probably will need envelope parameters to be changed (only when the use time modulation).
      • Added a pattern module, meant to be used for rhythmic figures in a more compact way than can be done with step sequencers. Basically it is a set of eight dividers, when a divider is started it will copy the trig input to the output on the first count only. Then when the divider counted down to zero a next divider will be searched, skipping all dividers with a count set to zero. When all dividers have their count set to zero there will be no output pulses.

      • Added an EuclideanScale module, a bit after what Kyma has in version 7, can set the number of divisions for the octave, and then a pattern selection can be applied to that. An ocatave still spans a factor of two with this.

      • Added an Interpreter module, it executes forth code at control rate. This is experimental, undocumented and subject to change. For now eight inputs are put onto the forth stack. Then a deferred forth word is called from Wren. This word can be hooked by custom forth code and that code should pop the stack values to do something with them. Outputs can be set from code by calling a predefinedootput word whenever such is needed.

      • Added a Convoder module. This module performs multiplication in the frequency domain which is equivalent to circular convolution. Nothing very speciall but it can give some nice reverb like sounds based on its input signals. It can sound a bit vocoder like too when used on speech signals.

      • Added a logic selector module, that when the select input is inactive passes its inputs A resp. B to its outputs A resp. B. When the select input is active it passes inputs A resp. B to outputs B resp. A (i.e. it swaps the signals then).

      in version 2015.2.26.0

      • Had an integer overflow in the Seq16 module when the module did not get clocked. This would stop sound generation in a particular patch after about 6 hours. The Integer is a counter used to measure the time between clocks and is used for interpolation. I've put a cap on it's value
      • Implemented value pasting, but did not test it yet. The idea is to select some modules, then do a copy to clipboard for those. Then select the same module structure elsewhere in the patch, or in anoter Wren incarnation's patch, and then paste the values over to that selection to get identical knob settings there. One could copy over the steps from a set of sewuencers to another set of sequencers for instance.
        It seems to not work yet, more later. Ok, there was an error for checking structural equivalence.
        It works now.
        • Made ModCompressor about 5 times as fast by getting some calculations out of the loop and optimizing the remaining ones a bit.
        • Sped up LFOs by about 10%.
        • ModReverb was sped up by about 15% — also changed the execution order of the allpass filters to be the same as in the original code, not sure if that would change anything (sound wise).
        • Sped up envelopes a bit by using table lookups for the power function.
        All in all that got about 10% off from the current patch's CPU load.
      • Re-implemented the FIsSlow mode request flag. A while ago I had settled on executing all modules in slow mode and only the ones needing fast execution in fast mode as well (with the FIsFast flag). With the reintroduction of the slow mode flag it is possible again to have fast mode only execution. I'm getting more detailed profiling information this way and patches seem to perform marginally better too. Module constructors need to now set Fast and / or Slow mode request flags always or their DoTick and / or DoSlowTick method will not be called (the TMod base module is neither fast nor slow). [Slow being control rate / blue signals, fast being audio rate / red signals].
      • Found hat denormal numbers could occur in SVF (again) and in FreqShifter modules resulting in stuttering for some settings. Added some Normalize calls to fix that.
      • CSV player would play 11 channels only instead of the 16 it was designed for — fixed now.
      • SVF Q calculation was wrong, changed it. It is still wrong but at leeast it is the same as on the Hrast Filter now (I should change both to use 1 / Q internally instead of 1 — Q … or maybe not … to not break patches).
      • Added a clocked delay module.

      • Added a bottom label to he graph to show timing to be in milli seconds (for some reason I always think it to be micro seconds), also added checkboxes to enable or disable individual traces.
      • Changed Pad module looks.
      • The Filter bank does not work yet.
      • Could use a SeqRandVals analog to SeqRandom, but then for random non-note values — no need for that, it is easily patchable.

      in version 2015.1.31.0

      • Got some 15% off from the execution time of the FreqShifter module, still not understanding really why it takes so long to compute. Well … 70 to 80% goes into the calculation of the Hilbert transform … but then again that's just about 100 multiply / add instructions. The vocoder does a lot more than that in about the same time. Hmm … maybe the vocoder does not do that much more … also looked at the compiled code for the FreqShifter, it is not that bad really, so this is it I guess.
      • Mute on Square and SquareTrig modules was not working, fixed.
      • Triangle amplitude was a factor four low after the anti-alias modifications, fixed now (for Osc and TrigOsc modules).
      • Pad module, with an X and an Y output, both simultaneously controlled with a mouse drag.

      in version 2015.1.23.0

      • When the FFTW DLL is not present some patches will not work. They will load though but they can not be compiled. When an old compiled patch was in memory that one will keep playing, and when there was no patch there will be silence … will need to issue a message for this situation. For now it will be the vocoder module only causing this issue.
        I've changed things so that an affected patch will load and compile but any FFTW dependent modules in it will just do nothing — a one time warning will be shown for this situation.
      • When words.lpc is missing and a Talkie module is used there will be a NULL pointer issue. I've changed the code a bit such that the Talkie module will show 'words.lpc missing?' in it's bank selector control when that file could not be found, or when it could not be interpreted. The file will be looked for in the Wren executable directory. Will try to get some better diagnostics on this at a later stage (for the case of parse errors).
      • Bugfix for SeqRandom, when 128 notes were in the scale there would be an integer overflow.
      • Added an exponential FM input for Talkie, and put a frequency range clip on it from 0 — System_Rate / 2. With no FM connected it will behave like the previous version. Also changed the layout a bit to create room for more controls. Added a bank select input, which when it changes value will overrule the manual bank selector control. Also made it work a bit different, Talkie will now only say something when it sees an upgoing edge on the start input (and it is no longer possible to change the phrase (or bank) while Talkie sqeaks).
      • Added trigger mode to SR FlipFlop, so it can now be edge or level triggered. The default mode is edge triggered for compatibility with old patches, However I also changed the workings a bit such that when a reset condition is present that will always overrule the set condition.
      • Implemented anti-aliasing for all audio rate oscillators. Algorithm based on this article about polyBLEP and the implementation of the HrastOsc, which uses a form of polyBLEP as well. I've added a band limiting level control, with a default level of about 1.5 — this will change the sound for existting patches — for better usually. For some special cases like modulating a delay line or a nicely whistling patch you may want to set the B-Limit control to zero. For high pitched voices you may want to nudge it up a bit from the default value.
      • Some stability issues with the anti aliasing code, had to mod the code a bit for that — copied from HrastOsc. The BLEP stuff did not like phase accu bound over/under-flows at all.
      • Added a 'friendly' label field in the designer for value controls, so the text in popups can be a bit more descriptive — filled in some, not all yet.

      in version 2015.1.18.0

      • Moved TerraGen module from Osc tab to FX tab. Reorganized LFO tab a bit. Made a couple of modules a tad smaller.
      • Changed the Debug Screen F5 and Settings Screen F3 a bit so they only have the buttons needed locally in the right pane.
      • Clipped all PWM to be in an interval of [ 0.01, 0.99]
      • I renamed a 'reset' input pin to 'res' on one of the sequencers, on reloading a patch with that you may loose connections — I will not fix that, and will keep the patch version at 2 as well — sorry about that.
      • Experimenting a bit with Talkie. And … we have liftoff — Wren speaks! Now I need to think about how to select what to speak from the 1200 or so letters / numbers / words / phrases available. When Talkie grows up it may look something like:

        I settled on that FTTB. Phrase selection is messy, but for random phrases its ok now. I like this module :-) Frame speed is liniarly modulatable between 0 anf 80 Hz, sample rate is liniarly modulatable between 0 and 16 kHz.
      • Would like xfade on seq16 module … it would need to calculate a time guess between steps … hmm … it would act one step late then on tempo changes. Ok, it can actually calcultate a period estimate on each clock edge, and it can be made such that when the xfade factor is zero it would not delay. It can however produce large over and undershoots then when the actual period changes fast. This can be clipped though, such that the final value is just reached early (or late …).
        With that I think I found a reasonable implementation for the single sequencer case (it works on direction reversal too). Should check it to work for chained sequencers as well, which probably it does currently not, but this may be possible.
      • Experimenting with a Sequencer Sequencer now, to make chained seuencers more reliable and easier to set up. Especially with interpolated sequencing.

        This seems to work well for chained interpolated sequencing too (although there still is a reset related issue). The clock speed is very high, to not have to wait too long for a trace to be made.

        Top trace is clock in (trig), then clock out (trig, with bit of delay). The orange track is reset. Then the enable for the top sequencer (for 16 steps), purple is the enable for the bottom sequencers (8 steps). Green is the output of the top sequencer, blue the output of the bottom left one (not cross faded) and the the red trace is the 100% cross faded output of the bottom right sequencer. (The bottom two sequencers have the same step settings to be able to compare crossfaded and normal signals.)

        Only the last sequencer in chain should have the xfade turned up, it will handle the upstream sequeencers too then.

        An asside: It is interesting to see how close this is to multi-stage envelopes, only the sustain phase is not there. With a small mdification on the trigger LFOs this could be done too, they would need a hold input only. The sequencer inerpolation could easily be made exp or log as well, might do that anyway.

        Ok, that works … now the backwards stuff … seems to be working too :-)

        Except reset is not perfect yet when running backwards … when the last sequencer has less than 16 steps the sequencers before will not start on the last step.

        There seems to be no such thing as a perfect reset, I've added a couple of reset modes for the SeqSeq module each having a different effect on how on how patterns will be played.

      in version 2015.1.4.0

      • Removed vocoder startup glitch.
      • Made sliders, a 16 step sequencer would fit now.
      • Made an audio mixer with two busses, 8 mono inputs with pan control and two bus level output controls. Also added mute and solo buttons on the inputs. It is chainable for when more inputs are needed. The first solo button seen will be the effective one, and an active solo will suppress solo actions in a chained module.

      • Varous issues with clocks. Square oscillators and LFOs started with a low output instead of a high, divider module would start on a down going edge and the Counter had a wrong start state. Sequencer would not always reset on short reset pulses. Also there were some race conditions in the Divider and the Counter making reset give unexpected results. Also the Sequencer output was one step off, at least … after the other fixes … GateSeq needed some mods too to make sequencer sequencing working, and its reset did not work nice either.
      • Added random and clear buttons to sequencer, added an active input as well to allow for sequencer sequencing.
      • Added active input to GateSeq to allow for sequencer sequencing.
      • Added reset input to Divider module to be able to use it for sequencer chaining. The example patch here shows how to make a 16 step sequencer out of 11 step sequencers — this is scalable to 16 sequencers, and to different sequencer lengths as well.
      • Added lights for GateSeq steps, added Clear and Random buttons as well.
      • Added a button left of the control panel with the main volume controls to quickly hide and get back those controls (near the top).
      • Added a direction input for the GateSeq.

      • And there it is … added a seq16 module. This one can sequence notes or values, it can be used for sequenced sequencing. It has a direction input and a random and clear buttons.

      • Directional sequencing is not direcly compatible with sequencer sequencing as shown in the image to the right. You'd need more logic for that, try to use a GateSeq instead of the Counter.
      • Source code release.
      • so anyway … your typical 41 step sequencer with gates, trigs, notes, volumes and filter cutoffs would look like:

      in version 2014.12.30.0

      • Added a VU meter clear on audio stop option, the option is on by default. Also can double click on any VU to clear them all.
      • Some code refactoring for file selectors and display editors into a TKnobsTextControl widget.
      • Images for mute buttons
      • Increased maximal compresssor gain to 64 dB.
      • Color modulation for most noise modules was not working, fixed that.
      • Added a basic vocoder. Note: this needs the The FFTW DLL to be present.
      • Support for two template files, a save function in the file menu and two load buttons in the editor. Also added export to file for selected modules and import from file to addth modules in tha tfile to the current patch … however that still sucks as the added modules will not go into drag mode …

      in version 2014.12.22.1

      • Source code release.

      in version 2014.12.21.0

      • MidiPlayer needs reset input and done output, the system reset does not work on it properly either.
        Changed channel offsets, depending on midi file type, ch 1 will be the first usable channel, skipping the meta channel for type 1 MIDI files. Added reset and done, fixed reset issues.
      • Issue with channels on MIDI modules, fixed now.
      • Program crashes on exit with incoming MIDI it seems, put a gard on that.
      • Issue with MIDI command processing on other channels than ch 1 — thank you Steve for testing :-)

      in version 2014.12.20.1

      • Oh fuck … and now it does not start properly when an ini file is present, selected devices are forgotten. Ok, it will in Legacy mode, but not for PortAudio mode.
        Ok, seems to start now properly with and without ini file and it seems to remember the device selections for both legacy and PortAudio modes properly noww.

      in version 2014.12.20.0

      • Added 'lowest' and 'highest' value outputs to Median module. Also allowing now for even valued settings for the bin size — a binary or trinary sorter can be made this way. Note however that an even setting for the bin size results in the median being the average of the middle two values (after sorting) and thus that this needs not be a value that was actually present in the input stream. The lowest and highest values will always be values that were present in the input.
      • Working on a simple MIDI player thingie — implementation will likely change.
      • There was a memory allocation still left in the Median module's DoTick method, removed that one. It caused occasional runtime errors.
      • TransInv module could do an occasional division by zero, fixed.
      • SeqRandom does not recalculate the scale after a scale change, it needs the range to be changed or the transposition. A patch recompile also works. Fixed that.
      • The MIDI CC output module had no synth binding, making it unusable, fixed that.
      • 2014-12-19 : Need to review Reset behaviour, the response to the Reset button. It may not actually cause a change in output values for some modules?
        The envelope modules did not set their envelope values to zero after a global reset indeed, fixed now.
        This may not not be completely fixed yet … reset should last for 'system_rate / control_rate' periods I think.
      • When wren.ini is not present things will go wrong terribly … made it survive that situation.

      in version 2014.12.17.0

      • I've installed Asio4all … ever since the RME ASIO driver works too, and I have 8 in and 8 out channels available :-)
      • Not all channel dB labels were updated, fixed that.
      • Added an ASIO control panel button on the device selection screen.
      • Added an audio test button on the device selection screen.
      • Added ASIO channel selection on the device selection screen.
      • Some bug fixes in device selection, and a better reset after device changes … such that the device test function could actually work without restarting Wren.

      in version 2014.12.12.0

      • Better colors.
      • Bug in TimeToSeconds routine, the conversion produced an invalid index. Fixed it.

      in version 2014.12.11.0

      • Added a couple of new modes for the Constant module, one of them being Note mode, for easier note selection.
      • Changed LfoTrig Ready ouput to only fire after a cycle was ran, and not just when being idle.
      • Added a TransInv module for note Transposition or Inversion, it can do so with a modulo operation being applied.
      • Found a better way to color modules. In the Settings Screen F3 you can set a default color and an opacity value which determines the color intensity.

      in version 2014.12.10.0

      • Added a GateSeq module, an event sequencer with per step 'off', 'trig' or 'gate' mode select.
      • Added a Pulses module, generates pulses with random intervals, either synced to an internal clock or free running. The 100th module type!
      • Added Exponential random distribution and Lambda control to RandomWalkLFO module, as a sort of jumpiness control.
      • Added Exponential random distribution and Lambda control to RandSig module, as a sort of jumpiness control.
      • Added a search option for un-connected modules (in the Edit menu, or use Ctrl+U).
      • Frequency range selector for RandomWalk LFO was not working, FM was not working either, fixed.
      • Put a guard on negative module top offsets to avoid ghost modules to be in the patch. This might solve bugs 2014-11-28 and 2014-12-08. Some old patches may look a bit strange after loading, as any ghost modules will be made visible now.
      • Changed the patch writer such that it will no longer write out modules with negative X or Y positions, it will instead shift all the modules by the largest offset it found.
      • Some bug fixes for sequencers and for the morse generator for division by zero and an undefined string index respectively, these were related to Port Audio and thread issues. Same sort of issue with XYScope, fixed too by making history an internal signal instead of a patch signal.

      in version 2014.12.6.0

      • Error in Delay module. When using PortAudio the setting of the delay length is from a different thread than the module execution. It did happen that way that the memory would be invalid at execution time. Fixed this.
      • Some issues with memory allocation for delay based modules and the EuclidianRhythm module. Memory was allocated and de-allocated form the audio thread. I changed that. Ah, and also the Under/Overflow debugging was a violation … moved those to the Lights updater (out of the audio thread). That way the normal memory manager can be used it seems — except maybe for debug messages — hmm … nope it can not.
      • Changed the implementation for multi channel such that it will open up to 8 input and output channels but never more than the Port Audio interface reports to be present. In theory this should give multi channel IO under ASIO (at least with my RME fireface UFX — except that ASIO refuses to work at all with it). Currently there is no way to specify which channels will be used though. I did some measurements on audio round trip times, see here for some results on my computer — not breath taking, but better than it used to be.
      • Device selection sucks … it is needed now to restart Wren when other Port Audio devices are selected — there is no need for that really, it is a bug. Changed things a bit, this seems to help. Also moved the buffer size selection to the wave device selection dialog.

      in version 2014.12.3.0

      • Improved XY scope a bit, it's not super but it found some bugs for me already.
      • Added a Compare module for signal comparisons, > = and < outputs. Equality holds when the inputs differ no more than the value set by the equality range control.

      • Added a 12 to one cross fading multiplexer.

      • Added a HardClip module for hard signal clipping, not really meant for audio distortion but more for signal conditioning.
      • Bug in delay module where the longest delay setting produces no signal output at all (on the variable delay time output). Fixed it, the interpolation code was wrong, every exact integral delay time (in terms of sample counts) would produce silence as the output on the variable delay time output.
      • Bug in the RandSig module, it should produce smooth glides from one random value to the next, but it has jumps in the output value. Ok, solved, it was smooth for the special case of non inverted full output swing signals only.
      • Bug in cents calculations, for oscillators a change of 25 cents amounted to a semitone … and for the Resonator module it was not working at all. Fixed now.
      • Error in the naming for the displays for cents, they were called 'fine' instead of 'cents' and could thus not be found back by the program — fixed.
      • I've made patch reset on render start optional, by default it will be on. When it is on the patch will be reset when rendering starts, when it is off rendering will continue from where the patch was. Setting can be changed from the Settings Screen F3.
      • Changed the Rotator to map an input swing from zero to one to a rotation of 2 * PI radians, this was just PI. Old patches will rotate twice as fast now.
      • Changed the Median module to have a larger maximum on the number of bins, 99 now.
      • 2014-05-17 : The terraGen module has some issues to be solved. Seems fine now after adding input clipping, have been using it in couple of patches.
      • Added info popups to more valued control types, like mute buttons and mode selectors.
      • Added mouse wheel support for knobs, this is off by default which can be changed and configured from the Settings Screen F3. On my laptop's mousepad two finger click drag will result into mouse wheel actions, and with that one a sensitivity of 50 seems about right. For fine control use the arrow up down keys while the mouse is still in the control.
      • Added a 'use unfocus' option that is effective only when mouse wheel support is on. When active and the mouse moves out of a mouse wheel controlled control the focus will be set to the channel one output volume control. This option is on by default.
      • Changed the default width of the panel with the main volume controls to only show channel 1. This can be changed by using the splitter to the left of it. Still … for the time being only channel 1 will be working for audioio. Also made the volume controls and device selectors for the non-working channels invisible for now and hid the unusable I/O connectors on input and output module as well. Also all the non working multi channel code was removed, this will have to be done differently once using Port Audio. The device selector was changed to allow for only one input and one output device to be selected, for multi channel operation the devices will have to support multi channel operation.
        Added experimental support for Port Audio, this needs a portaudio.dll file to be present in the application directory or somewhere on the Windows path. It will not work properly for multi channel I/O yet (i.e. ASIO). For Port Audio the buffer size needs to be set smaller than for legacy mode, large buffers may perform worse.
      • Sped up calculations a bit by getting rid of some FModulo operations, and optimizing the remaining ones with some assembly code.
      • Removed the global Scala related settings, any future Scala support will be through the Scala module.
      • Added a Scala module, which can read in a Scala scale file (.scl) and a Scala keyboard mapping (.kbm). It translates incoming note values according to the Scala files loaded into a signal suitable to control FM inputs. For this to work as intended oscillator frequenciy should be set to 440 Hz, for filters likewise.
        Sofar I've tested this only for a trivial mapping using all keys 1:1 with a 12 TET scaling. This works, but there probably are some subtleties that I missed …
        And indeed some other scales I tested give output differing from what Scala computes. Anyways …still experimental.
      • Text sequencer bug, it does not work at all, and causes a division by zero. Ah no … it wants commas, and it does not like spaces … fixed the spaces issue, the commas are needed still. And the help was wrong, it said spaces where commas were meant. It still needs a new parser … as mentioned elsewhere.

        A couple of changes on it: values can be just values or notes, a modiefie like Hz or s can be part of the value when it is numeric. Values need be separated by commas and after a value a repeat count can be set separated by a colon (:) from the value. When there is no repeat count the implicit repeat count is one. Anything not understood will be interpreted as a rest. A rest or a repeat will not trigger the gate ouput (new to).

        An example string 'A1:2, 333 Hz:3, _, C1' first A1 will be output for two clock periods, then 333 Hz for 3 clock periods, then a rest for one clock period ( extending the 333 Hz signal for yet another clock time) and finally C1 for one clock period.

        2013-11-20 : Make durations for the text sequencer, and a more forgiving parser.
        2014-11-30 : For the text sequencer add a way to play rests, that is add a gate output and some special character to indicate that a rest should be played, e.g. a note time slot is to be skipped.


      • Added atan mode to TerraGen module, to be used as a soft clipping function. I've been complaining about the TerraGen a bit in the past, but it does not seem too bad now. I did add some input clipping to it, maybe that changed things. It did not get too much thought.
      • Had forgotten to turn on the MustSave flag for the display of the Notes module, so notes were not saved. Fixed now. Also text values were not quote escaped, so when a quote was added to the text the patch would not load anymore after a save. Fixed that too.


      • Instability issue with SVF when Q = 0, fixed. In older versions set Q no lower than 0.01 (1e-2).
      • Start of rendering should first issue a reset. The sequence F9 to stop the patch, then hit reset, then start rendering does not seem to work. Will have to look into this.
        Two things, FixZippers was not called on render start, meaning knob values would be stuck low for a while when a patch had not run before render start, and Reset was not issued either, meaning rendering would start off from where it was. Fixed that.


      • Bugfix xfade module ... and the same one in Pan module - had mixed up the knob and the control input
      • Bugfix pluck module, the mute button was not working.
      • Added random distribution controls to SeqRandom module, and removed the change all input from it. Also added random distribution to RandomWalk module.
      • Added color control modulation to Noise, NoiseTrig, NoiseLFO, NoiseLFOTrig and RandSig and modules.
      • Added modulation for the alpha parameter on the Average module (untested).
      • Added a phase detector / filter module, as a building block for PLL circuits.
      • Fixed the chart mode to work for non debug/profile builds again.
      • Pluck oscillator suffered from denormals .. fixed that.
      • Added a Morse generator.
      • Bugfix for the RandomWalk module, the random distribution stuff made the code essentially non working.
      • XYScope module, this is not functioning properly yet.


      • SeqRandom, a random notes module. A scale can be set with a base note and a lowest note and a highest note. A step count can be set and on each trigger a next random note fitting the set conditions will be played. When the last step is passed the sequence will repeat from the start. A pulse on the random input will select a new set of notes for the sequence. Sequences will not be saved with the patch.
      • Made the reverb module to scale with the sample rate, it should sound better at higher sample rates now.
      • Made new images for signal polarity selectors on LFO and Envelope modules.
      • Made a multi sample and hold module, one trigger input controls multiple sample and hold units in one module.
      • Added some extra in / out pairs for the multi multiplier module.
      • PluckOsc added, a Karplus-Strong model.
      • New mixer, T1to1, a one input chainable three channel mixer.
      • Logic divider forgot to clear the ResetFlag, so after one reset it would stay in reset mode - fixed that.
      • Fixed a bug in most of the sequencers .. had 'optimized' some code, they were not working at all anymore.
      • Added a new FX tab and moved some effect modules there. Also moved the wave player module to the OSC tab.
      • Added a zero crossing based frequency detector.
      • Added a resonating filter with decay instead of Q control.
      • Added a Bode frequency shifter module. The Bode shifter shifts all frequencies by an equal amount, meaning that harmonic relations between overtones willl be changed.
      • Added a running median filter. The median of a set of values is calculated as the middle value of that set after the set was ordered small to large (only odd sized sets are supported to a maximum size of 25). On each clock a new value is added to the set and the oldest value drops out, then the median is calculated and sent to the output.
      • Changed some initialization stuff, had to modify the HrastUnit a bit for that.


      • A counter module, can count binary or sequentialy, up or down and it has a reset input too.
      • An ADConverter
      • A DAConverter
      • Fixed bug in pan module, the knob would go center to right only, not left to right.
      • Added a multmult module, where four inputs are multiplied by one common multiplier into four seperate outputs.
      • For BitCount = 1 I've changed the gate module back to it's old functionality. The boundary conditions were a bit odd with the new code.
      • Added level modulation to mixers MixM4to1 and MixS2to1.
      • Added position modulation level to Pan and XFade modules. The controls are fully open by default to be compatible with older patches.
      • Added control depth knob to formant filter. The control is fully opened by default to be compatible with older patches.
      • Made glyphs for output mode selector on some LFO and Envelope modules.
      • Made glyphs for wave shape selector on some OScillator and LFO modules.
      • Made a compressor, or actually it's an AGC more. It is feedback based in that it tries to maintain a set reference level at the output. In doing that it can both apply gain (for weak input signals, with a maximum of about 30 dB) or reduction (for strong input signals, also about 30 dB). Reaction speed can be set with an Attack control and fallback is controlled with a Release control. A pre-amp is included to be able to shift the set point easily.
      • Made a KleeBit module, which is 8 steps of a Klee sequencer. The bits can be chained to make a 16 or more steps Klee sequencer .. with some external glue.
      • Added a 3dB/octave (10db/decade) pink filter, to pinken up white noise.


      • Instability issue in Flanger/Chorus module solved.
      • Output types for all LFOs: 'Normal', 'Inverted', 'Positive Only', 'Negative Only', 'Positive Only Inverted' and 'Negative Only Inverted'.
      • Activity light on NoiseLfo was not working.
      • Output types for AHD and ADSR envelopes: 'Normal', 'Inverted', 'Normal Negative' and 'Inverted Negative'.
      • Looks like the knob popups can be hanging at times ... made a breakout for it F8 will work.
      • Colored border on modules, user selectable.
      • Slow fall off on the display module (VU meter) .. instead of drop to zero immediately ... which sorta worked with the old lights update regime but not at all with the current one.
      • Finally found a nice compact form for an Euclidean rhythm generator (a variation on Bresenham's line drawing algorithm, read more about that here), and turned that into a new module. [On the sequencer tab, 1205]
      • Added a fast mode to the display module to have the meters react faster. This sometimes better fits the data to be displayed.
      • Added a CSV data module, it can read a Comma Separated Values file with up to 11 columns of data. The data is being clocked out with a trigger input, it can play forwards or backwards and there is a reset input. There is an option for playing the file data once or looped. When the mode is set to once the data sequence will start again after a reset signal on the reset input (or the global reset button being clicked on). Comments in the CSV file start with a # character, when a comment is on a non-data line it is ignored when the file is read, when it is at the end of a data line it will be displayed in the module for that step in the sequence. [On the sequencer tab, 1206]
      • Added digitizing to the logic modules, they used to convert the input into a single bit value (which is still an option) but they can now digitize to longer bit vectors as well. The logic function is then executed on the vectors instead of the single input value. Also changed the XOR and XNOR functions to perform odd and even parity respectively. Added two new functions ONE and NONE that behave like the old XOR and XNOR functions did, the output going active / inactive respectively when precisely one input is active. The bit vector stuff will not work on these two new functions.


      • 2014-04-08 : Floating point overflows in places ... some input clipping is needed, but not sure why signals get so large in the first place.
        Okay .. it was SVF instability ... probably fixed now.
      • There was still debug info present in the release build, removed that, shrinking the exe size quite a bit.
      • Changed the way rendering works .. it does not generate live audio anymore. The thread's priority level is set to 'idle' so it wont hog a complete CPU. A limit can be set for the maximum recording duration, or it can be set to zero (or blank, or any string value that can not be translated into a float value) to make it record till the file reaches a size of 2GB. At any time the rendering can be stopped which will close the file. Likewise, leaving the program will close the file too .. or when an exception was raised .. the file may be shorter then than expected.


      • Set all floating point exceptions to be masked for release version. Also clearing any exceptions after Tick executed (so errors wont propagate).
      • Added a property selector utility to set the value for the ControlType property on knobs more easily. This is a module design time feature only, it changes nothing for the synth itself ... although ... for some odd reason this halved the size of the executble tho o_O .. for the curious, it's in the knobs2013.pas unit.
      • There seem to be some numerical instability issues in one or more of the modules ... the program crashed on me last night. This may have to do with FPU exception masking and how windows deals with those, when the masking is set different from the windows masking even something simple like Abs( reasonable_value) my trigger a floating point exception.
      • Added sum output for scaler module, it gets the sum of the other four outputs.
      • Made 'inverted' output for envelop module, this one get the difference between the peak value of the normal output and the current value of the normal output. The idea being that with this output it is easy to make something get louder when something else gets softer. Using the peak value will prevent the inverted ouput from going negative, but it will take some time to settle. Also added a peak decay option on this with selectable time.
      • 2014-06-02 : Render to file option. Rolled my own RIFF writer for this .. may do a RIFF reader too now .. it seems not too hard ... anyway, did some tests and the WAV played in VLC, WMP and CoolEdit here, so guess they are fine ... no file length checks tho ... so be careful when it goes over 2 or 4 GB, the code could do 4 I think.
      • Had to split the knobs2013 componenents into a runtime and a designtime package. Turns out that in order to be able to make design time property editors on has to specify an extra compiler option -LUDesignIDE (or elese Delphi will not find it's design interface ... ), but this causes the program to be linked with runtime packages ... which then in turn causes users to complain ... Anyways, when you want to compile your own you need to uninstall the knobs2013 knobspackage and then install the new Knobs2013Design package. Also added a couple of missing icons to the DCR file. This explains the file size halving too.


      • Made popup menu's for selectors, so you can now right click on say an Lfo speed selector or a mute button to select a value directly instead of clicking to cycle through the values. Selectors currently are indicated by a yellow border.
      • Working to port over a FlangeChures and a PitchChanger I had laying around since the Turbo Pascal days .. or was that Borland Pascal ... old anyway .. from the days one could directly make interrupt code in Pascal. There seem to be some overflow issues to be sorted out. Some issues still with negative rates for the frequency shifter.
      • Removed profiling code for releases, this makes the program run a bit faster.
      • Fixed hint / popup window for knobs to keep displaying when the value is changed with the mouse. F8 will show all knob popups .. not too useful actually.
      • After patch recompile dezippers are set to the final value immediately now to stop the slow glide-in that happened.


      • Changed the module designer a bit, such that the module's PageName property will be automatic if the module happens to be on a TTabSheet with a non-empty Caption.
      • Changing some signals for AHD and ADSR modules to control rate to make them more efficient.
      • Changed the trigger lights on AHD and ADSR modules, they are on now when the envelope is in some active state, i.e. they now indicate envelope activity and no longer the presence of a trigger signal. This works better for very short trigger pulses taht would not be visible otherwise.
      • Removed the denormalized exceptions from the floating point exception mask to be able to find cases of denormalized numbers. As a result of that I've added Normalize() calls in a couple of places (Including the HrastUnit).

        This code will only be active in debug compiles of the program, to help find execution speed issues.

        All of this seems to have sped things up a bit.
      • Made update rate for lights user settable (settings page - press F3).



      • Interpolating random signal generator. Moving from current value to random value at a rate determined from the frequency it runs at - smoothly.
      • Mute was working the wrong way around on Noise and TrigNoise modules. And for LFOs dito.
      • Made a built in rectifier for the intdif dif output, so it can be used for trigger on signal change operations more easily.
      • Square thingies not working unless PWM modulation is being opened up - fixed.
      • Envelopes still act strange ... seems better now, removed some code


      • 2014-05-01 : HrastOsc vintage knob must not be in the knob map - fixed that.
      • User selectable sample rate: 44k1, 48k, 88k2 or 96k. Also changed the control rate from being 'sample rate' / 4 to 'sample rate' / 8.
      • Moved intdif module from control page to filter page and changed it's type ID from 312 to 1003. When an old patch will not load anymore please change the type ID for all intdif modules (type = 312) to 1003 - this can be done with any text editor (like notepad).
      • Removed lights handling from audio loop and made it timer driven instead.
      • Removed some synchronization code that did nothing.
      • Some more LFO range issues fixed, forgot range for SquareLfoTrig.
      • Added Lin range for LFOs, the FM will work linear then too. For trig LFOs this means that they may never finish their sequence.
      • 2014-04-30 : AHD envelope has clicks it should not have. Had A and D shapes reversed, looks like a click on the attack phase is more acceptable than one at the end of the D phase. This may need a bit more work later.
      • Added exception handlers for synth engine crashes. This will stop audio processsing and issues a message about that .. instead of the usual four ...


      • Fixed square LFO speed range selection, I had a typo.
      • Made the quantizer working again, also it displays note fractions now instead of arbitrary numbers. To do that I moved the rationals source module from the project itself to the knobs2013 package.
      • Fixed LFO out lights, another typo.


      • Major overhaul in how knobs are handled internally. The patch version has to be changed as a result, and current patches will not be compatible with this.
      • Made a popup menu for connectors - this sort of works .. break is not quite what I'd like yet - it should break the downstream connections, but currently also breaks the upstream one. Delete deletes the whole connection tree where the connector is on. Disconnect removes this one connector from the tree.
      • Made a module popup menu too, with cut copy and delete options.
      • Made a knob popup menu as well, added default values for knobs and the default can be set from the popup. Knobs can be locked and unlocked from the popup too. When an editable display is associated with a knob editing the value through the display will lock the kob to prevent the edited value to be changed by knob movements. The lock can be undone by unlocking the knob or by setting it to it's default value.
      • For 'File Save As ...' cut out the path in the save dialog to only show the file name there.
      • Changed the connector coloring a tad.
      • Had messed up oscillator frequency calculations, they were two octaves too low, fixed now.
      • 2014-03-03 : It happens on module insertions that the lights will not be updated (properly) anymore. It can also happen that a knob on a module controls something on another module. So it looks like the patch compiler has some issues. This seems fixed now.
      • 2014-03-28 : When an envelope of type AHD or ADSR is in fast mode and the patch is then saved the values will not always be properly set after reloading the patch. The same thing happens when such a module is copied and pasted. This seems fixed now.
      • 2014-04-01 : There is an issue with Knobs and setting values ... like an oscillator frequency by default is 440.00 Hz but after some messing with the mouse on that knob it is impossible to get that value set again. Only way to get it back is to drag the knob all the way to one of it's ends, then use the cursor up/down keys to try to get past that end, then use the cursor keys to step all th way back to the value ... yuck. This seems fixed now.
      • Defaults, stepcounts and ranges for several modules were changed.
      • Sequencer chaining would crash things on a floating point overflow, fixed.
      • Adding lookup tables, my earlier conclusion that they were faster only marginally was wrong. This will limit modulations to foreseen ranges though, and some value clipping will be needed. See previous point tho .. this would be needed anyway.
      • Cleaning up code, there are duplicates all over the place and bits of unused code too.
      • Adding speed ranges for LFOs, Slow, Medium, Fast and BPM.
      • Selectable waveforms for LFOs and oscillators to reduce the amount of modules a bit. Sine, Saw, Tri and Square.
      • Changed peak level indication for main in and output displays to slowly fall off, also added clip indication with a highlight color on those.
      • Reversed knob direction for Average filter. So now the cutoff frequency get higher when the knob is turned right, like how a filter works.
      • Removed the logic gates And .. XNor and replaced those by one Gate module with a selectable logic function. The same functions are available still.
      • Removed variable input count stuff, it had been disabled anyway.
      • Fixed bug in rectifier module, full wave mode did not work.
      • removed linear LFO and OSC stuff .. need to rethink that.
      • Repeats on the up / down knobs under knobs work just once and then never again. Ah .. forgot MouseDown := False in MouseUp handler, that fixed it.
      • Added HrastSVF 12 / 24 dB resonating filter.
      • Added cents control to HrastOsc
      • Frequency fine control for oscillators added, in cents. Range -50 to +50.
      • Added dB / Linear control selection to mixers, changed some attenuaters to dB mode here and there, added some level controls here and there. Renamed some stuff now that the patch versions are incompatible anyway.
      • De-zippering added for knobs on modules, inputs to be de-zippered can be added to a knobmap (at compile time) and the process will then be automatic.
        This will not work on mute buttons that use the SignalToLogic function to decide what to do, best to use SignalToMute( FInCache[ x]) * OutLevel or somthing alike instead of an if then else thingie.
      • Added exponential FM control for wave player. To use this the speed input must be connected to a signal source unequal to zero.
        Could have made the speed input to default to 1 to solve this , but then the position input would need the speed input to be set to zero ... compiled patches ideally would know if an input is connected to solve this issue.
      • Added color to random walk module
      • Added attenuators to square LFO and OSC modulation inputs.
      • Added time modulation for AHD and ADSR envelopes.
      • Fixed bug in AR and ARretrig envelopes that became visible after adding the dezipper code, it would try to dividde by zero.
      • Fixed bug in triggered LFO and OSC modules, they did not stop running always.
      • 2014-04-02 : Module paste can still mess up the module layout, and also can get modules at negative offsets still it seems.
        Looks like I finally nailed the the problem where the module lights stop working after a new module got inserted, or rather it would stop after a module was moved in the editor ... this was partly treated as a patch change and partly as a no change, resulting in the editor modules to be renamed and the patch not being recompiled - I've deleted the editor name changing line.
      • Repeats on the up / down knobs under knobs work just once and then never again. Ah .. forgot MouseDown := False in MouseUp handler, that fixed it.
      • 2014-04-01 : Unit interpretation in displays for knobs is not correct.
        I think this is not relevant anymore.
      • Fixed some graphics stuff that got broken over the months.


      • Window state saved in ini file, when the window was maximized on exit it will be set maximized again when the program is restarted. Minimized state is forgotten though.
      • Added a reset button which resets some module state on click, there are likely issues with this as reset is not as trivial as it may sound.
      • Added mutes per input on MixM4to1 and MixS2to1 modules.
      • Solved issues with output module, it does not need to be connected anymore and there can be as many as you like. The AudioOut module now gets compiled as any other module, removing the need for special stuff in the main program. TAudioOut is now treated as special in the synth engine itself. All inputs from aydio outs will be added there and the result is then copied over to the output terminals of the synth patch. The output mapping stuffthat was used is no longer needed.
      • Solved issues with input module, it does not need to be connected anymore and there can be as many as you like. The AudioIn module now gets compiled as any other module, removing the need for special handling in the main program. It is now treated as special in the synth engine itself where values from the engine's input queue are copied over to the outputs of all the AudioIn modules present in the patch. The input mapping stuff that was used is no longer needed.
      • Solved issues with knob default values of zero to not be used.
      • HrastProgrammer contributed a HrastOsc bandlimited oscillator module, thanks Hrast!
        I Changed the module layout a bit for this one to make it fit better into the scheme, and also added a little code to it to make sure that disconnected cables on control inputs will be reset to zero.
      • Fixed the situation where knob values zero could not be a default, changed some default settings for some modules.
      • Added the program icon to the source tree.
      • Fixed the project's DPR file, Delphi had put some crap in it.


      • A little speed up for filters and oscillators, changed some signals to control rate. FM stuff may sound a bit different now, however I did not change the linear OSCs.
      • A patch changed warning on program exit. This is on by default but can be turned off in the settings screen.
      • Added a debug indication in the title bar for the debug version. A debug compile is less efficient and should not be released by me, but I might do so by accident.


      • Removed dependency on TLed component. New Source code (2014.3.29.0, build 57) published.


      • Stereo wave players. Wave players still need to be 44k1 samples/second 16 bit wav files, but now both mono and stereo files can be loaded. For a mono file the L and R outputs will have the same signal, for a stereo wave the mode can be set to stereo or mono. When set to mono L and R will both have the sum (divided by 2) of the left and right channels from the wave. In stereo mode the L output will have the wave's left samples and the R output will have the wave's right samples. Added an indicator to show wheter the wave itself is stereo or mono.
      • Chainable 6x6 mono matrix mixer module.
      • Source code for 2014.3.28.0 (build 56) is made public, see the Downloads section. The customif components have changed, so they will need to be recompiled too (before recompiling the new application).
      • Search shortcut changed to CTRL+F


      • Bugfix - some patches could not be read, and sometimes modules could not be copied because the patch reader would not accept values in scientific notation (like 1E-12).


      • Search function on module title, highlights found modules, F7 shortcut.
      • Support for netMIDI / tangle, MIDI over TCP.
        This got implemented by using the Overbyte ICS TWSocket component. When you want to compile WREN yourself you will need to install that component. It can be downloaded from here, look for ICS.
        A zipped up netMIDI executable is available for download from here - see the Downloads section (netmidi.zip). Will make source code available at some later stage - it is old Delphi code and it needs to be ported to Delphi XE5 first. The old code is available on request though.
        Note that MidiTangle can probably be used as well http://jcfmusic.com/miditangle.htm
      • Rectifier module, MinMax module, Integrator/Differentiator module, MIDI note receiver module, MIDI CC receiver module, MIDI note transmitter module, MIDI CC transmitter module.


      • Horizontal and vertical knob change modes, in addition to the circular one used now. Built in a treshold for movements as well, such that after the click a minimum distance has to be moved with the mouse before the value will change.

        Ok .. it sorta works .. except for knobs near the edge of the screen ... would have to make the mouse cursor invisible .. jump to screen center then handle the moves, then jump back to start location and make the pointer visible again .. that is for later.

        Hit F3 to go to the settings.


      • Made a 2D vector rotator.
      • Made a ready output on the triggered LFOs, and a sync output on the other LFOs.
      • Made a file open dialog on the wave player and now display only the file name and not the full path anymore. Old patches will still load OK.
      • Added control knobs to xfade and pan modules.
      • Added sequencer step outputs that go active when the step is active.
      • Added sequencer chain input.
      • Added some mixers, 4 to 1 chainable mono and 2 to 1 chainable stereo.
      • Fixed the problem where loading a new wave player into a running patch would crash the synth.


      • Made oscillators and LFOs with linear frequency control - not quite happy with those yet.
      • Ratio control module to multiply a signal by some ratio, like by 5/8 for example.
      • Added D and RS flip flop types.


      • Combined WavePlayer and WaveStorage modules into a new WavePlayer module that both has speed and position control. When a patch with a WaveStorage module is loaded it will be replaced by a WavePlayer module.
      • Added duration ranges (speed) to AHD and ADSR envelope modules.
      • Logo and some looks changed.
      • Help system changed so that it talks about the modules as they appear in a patch rather than as how they are seen by the synth execution engine. The help text for the modules is now set from the module designer rather than from code.
      • When F1 is pressed and a module is selected in the patch editor the help will try to directly move to the help for that module.
      • Added images to the hint / tooltip windows popping up from the module selector.


      • Some scrolling / panning issues .. it still sucks, but less so.
      • VU meter looks changed.


      • 2013-11-23 : Look at notes / octave setting and the 440 Hz reference setting, does it really have to affect LFOs too?
        No ... made LFOs independent of that mechanism and based on 12 notes / oct and a reference A of 440 Hz.
      • A wave player with variable speed playback and made a wave storage unit too, that one has a position input meant to be controlled from a sawtooth wave. The storage module seems more flexible, as it is easier to set begin and end points on the wave by constraining the saw amplitude and offset, and also by FM modulating the saw there is a form of pitch control. When the saw is inverted it can still play the wave backwards.
      • Changed the looks a bit again, new knobs mainly, shifted around knobs, texts and connectors here and there, fill color for envelope graphs added, clearer connectors.


      • Fixed the issue with moving selected modules being way too slow. However when a bunch of modules are dragged too high up module restacking may change the order of some modules still.
      • 2013-11-21 : in TConnector.MouseMove make the wire panel scroll when the mouse goes out of its visible area, but do not scroll beyond the current size (as defined by its module content).
        2013-11-22 : Autoscroll needed for when modules get dragged out of view and when wires are dragged out of view. Ths scrollbox should keep the point where the mouse is in view in those cases.
        Implemented "follow mouse" for cable drawing and module placement such that when the patch editor has scroll bars it is still possible to patch with it.
      • Semi fixed the arrow icons on the 'noknobs' (as used for instance for note slection on sequencers). This will need a better soluition at some stage.
      • Started implementing mousewheel messages to perform scrolling. Vertical scrolling works OK now, horizontal not quite yet.


      • Fixed crashing popup editors.


      • Ported application from Delphi 2009 to Delphi XE5.
      • Fixed delay control knobs


      • 2013-12-17 : S&H bug, it acts like T&H. Fixed now.


      • Made the lights update a factor two slower, gives room for about 10% more modules it is a bit more sluggish now tho, light wise. was about 86 ms, now about 12 ms or just a tad slower than 6 Hz.


      • 2013-12-16 : Locale issue - patches saved in a locale that uses a comma for the decimal point will save patches with that comma, but on read back the program insists on a dot. Ah .. and that went wrong on internal representations too. Looks like fixed ... global locale settings needed to be set OK. Reported as fixed too now. too.


      • Added focus visibilty and keyboard arrow handling for TKnobsValuedButton(s)
      • Sped up sine oscs by 25% or so.
      • Made the bar indicators display dB's instead of arbitraty units, the Display module also works now.
      • Got rid of the TKnobsValuedButton)s), made a new TKnobsSelector component which is smaller and looks better.
      • Added mute buttons to a lot of modules, about 30 in total, tested most of 'm. The envelopes have a three mode mute function, it can set the envelopes to pass through the signal evenwhen no trigger comes in ( pass mode, the other two modes being unmuted and muted).
      • Profiler gives some more detail, like wire performance and overhead. The lights on the modules are nice, but it seems to be like 25% overhead comes from them.
      • Changed some colors.
      • Streamlined text to value conversions, so they work the same everywhere now. It also accept both note notation styles A#4 and A4# now, and even A#4# .. oh well.


      • Lil fuckup with text sequencer and optimization of initialization code - it crashed the text sequencer with a division by zero ... anyway, fixed now. It needs a small modification to the TKnobsDisplay component .. didn't reflect that in the published source code yet.


      • Fixed tab order on modules and added tab stops on some controller widgets that didn't have it yet.
      • Made all value displays editable (so values can be set with better resolution than is possible with the knobs). It should also be possible this way to enter different modifiers from the default one's - like use note names for an oscillator.
      • Value displays can be 'tabbed to' as well now.
      • A new way added to open an editor window - tab to the value display or click on it and then hit enter.
      • Several small optimizations in the drawing routines, and less unnecessary screen and synth updates.
      • 'Move final' behaviour on knobs changed - this mostly affects the delay lines where new memory will only be allocated when the total time had not been changed in the last 739 ms.
      • Added offset parameters for the editor, so modules can have a fixed small border on the left and top, making it easier to select modules near the left or top.
      • Changed contact details in the about box, and in this file, to point people to the electro-music forum.
      • Added a RandomWalk module - or brownian noise as some also call it. In this one a virtual particle performs a random walk in a confined D space, when it hits a wall it'll bounce off. X, Y and Z outputs are available as outputs.
      • Made the lock mechanism on the scaler modules work, in lock and antilock modes the knobs movements are synchronized. This way it is easier to to scale a value and offset tit at the same time. See it as a modulation depth control.
      • Some visual details changed, like LEDs a bit bigger, symbols on modules lined up better
      • Envelope shapes in documentation are better now, some preset display types added for the TKnobsDataViewer component. Mainly a 'design time' item.
      • 2013-11-23 : DEL key not always working for module deletion, and then ctrl+DEL does not seem to work either. As if the patch thinks deletions are not possible. This seems fixed now.
      • 2013-11-19 : Get knob changes into undo history. Did it.
      • 2013-11-19 : Compile less often. Did that too.
      • 2013-11-18 : on edits of the text in the text sequencer the synth is reported crashable, prolly related to the one below. Sofar I've not been able to reproduce this on various 7, Vista and XP machines. Unreproducible.
      • 2013-11-18 : someone reported an OSC module disappearing - leaving some wires to go nowhere, prolly related to the one above. Sofar I;ve not been able to reproduce this on various 7, Vista and XP machines. Unreproducible.
      • 2013-11-18 : there is a bit much latency from input to output. Maybe start using directx instead of legacy audio., such would prolly improve device name displaying as well in the audio device selector. DirectX will not solve this for Vista or later ... maybe look at ASIO later, or the underlying mechanism used by ASIO.


      • There was a problem when pasting multiple modules with the mouse capture keeping stuck on all but one module, fixed this.


      • Some new modules, some bug fixes, renamed all controls, old patches will not load anymore (but forgot to change the patch version). Old patches can be fixed in a text editor BTW.


      • Ran into some float denormalization issues making some patches about 15 times as slow as needed. Added undenormalization on many outputs and also reconsidered the antirunaway code a bit. This now prevents absolute signal levels from both getting too high and too low (too close to zero). erm .. this could be formulated better ... the anti runaway code now also prevents float denormalization to ripple through.
      • Added some profiling code, so that one can see now how many processor clocks are needed for the tick and slowtick module methods. Run a patch for a while, then hit the profile button. This will make a file profile.html in a data subfolder of the application folder. So one can see the computational bottlenecks.


      • The keyboard shortcuts got some more attention, seems ok now.
      • Added a fixed delay output on delay modules - this one gives the maximum delay as set by the delay knob, it is not modulated.
      • Changed the output name for Avreage filter to LP and added an HP out. Also changed knob response for this module to give better resolution at the high end.


      • 2013-11-25 : New envelopes have clicks that don't belong there, ah no .. it's a gain issue ... the published version has non working gain, and on trying to fix that I got the clicks. So ... gain on the new envelopes does not work.
        Fixed now, gain works, no clicks.


      • Added two new envelope modules, AHD and ADSR with them nice envelope displays that respond to the knobs :-0


      • 2013-11-23 : Divider indicator not working, and some more. Fixed various little issues for this release, enough to be able to actually do my first noodle with it :-)
      • Source code for 2013.11.23.3 is made public, see the Downloads section. The customif components have changed, so they will need to be recompiled too (and before recompiling the new application).


      • 2013-11-23 : LFOs run a factor 2 too slow. Fixed.
      • 2013-11-23 : Look at filter tuning, needs rescaling like the OSCs had it and it seemed off before. Filter tuning did not work at all, fixed now and tuning seems to be about right.
      • Changed the Looks a bit
      • Display editors can handle ENTER now inside text, use CTRL+ENTER to close a display editor.


      • Had forgotten to convert the trigger OSC and LFO stuff for expo control. Also trigger lights on those modules did not work. also had forgotten the SVF.


      • 2013-11-18 : Exponential frequency control. That, and rescaling of knobs for frequency control on oscillators and LFOs. Also removed the quantizing to knob steps, so that once editors are available for values all arbitrary values could be set (within the resolution of an IEEE double float).
      • Implemeted a setting for notes / octave, not sure how useful that is as it is.


      • Various changes in the user interface, added an about page, recent file history, patch name editor, added some keyboard shortcuts (F2 will show the editor, F3 the settings).


      • Name changed from 'modules' into 'WREN'.


      • 2013-11-21 : When a new version runs and F1 is pressed the help files should be regenerated - did it.
      • 2013-11-20 : it was reported that when scrollbars appear displaying the visible area starts to behave odd, sofar I've not been able to reproduce this on various 7, Vista and XP machines. Ok, I see what was meant now, working on it. Seems fixed.


      • 2013-11-18 : SVF seems to lock up for (very?) high or low FM values. Added clipping for the sum of frequency and fm to a range 0, 1.
      • 2013-11-18 : Feedback delay loop seems to lock up under positive feedback conditions. Added cliping to range -16, 16 to input.


      • 2013-11-20 : trig lights on AR modules not working, the names are wrong - changed the names.
      • 2013-11-20 : Note number to signal and signal to note number do not work correctly for 'negative' octaves - (i.e. A-1) this needs a mathematical modulo calculation and floored division to make it work correctly. Introduced two new functions Remainder and FlooredDiv to perform modulo and division for this case.
      • 2013-11-20 : Make a logic NOT module - did it.


      • 2013-11-18 : Pressing DEL in an editor :: Changed the DEL behavior a bit, removed it as a menu shortcut and instead let the application handle it. the application will first ask the editor if modules can be deleted, and if so it will do that and mark the key as being handled (so it will not be passed on to anything else). When the editor is not in a state where it can delete modules the key will not be handled by the application and be passed on to the control that has keyboard focus (i.e. a LabelEditor (for module labels) or a DisplayEditor (for the notes editor in the TextSequencer). This way the DEL key can still be used for both functions, delete modules when possible and delete text from an editor otherwise.
        For another way to solve this see http://embarcadero.newsgroups.archived.at/public.delphi.vcl.components.using/201009/1009246070.html


      • 2013-11-18 : pressing DEL in text sequencer editor will delete the module while the editor is still open, crashy stuff from that
        'Solved' with a bit of a kludge - module deletion is not possible when there is an editor open - either on a text sequencer or on a module title (which has the same issue).
      • 2013-11-19 : The resource files customif.dcr and bitmaps.res are missing in the source zip - made them seperate downloads for now, they go into the customif project folder.


      • 2013-11-19 : Get some unused stuff out - diddit.
      • 2013-11-19 : Show input buffer over and under flows in debug screen - diddit.
      • 2013-11-19 : Fix error with quotes on version number - diddit.


      • 2013-11-19 : Make version numbers visible in the program - on the settings page.


      • 2013-11-18 : A shorter delay - made it.
      • 2013-11-19 : Random picks from text sequencer, as a random lookup table - added a robsol mode.
      • 2013-11-19 : Introduce patch versioning, the proposed change from lin to exp frequency control will make patches incompatible - current patch version is 1.
      • 2013-11-19 : Globals.pas in the customif stuff should be renamed, two times the same filename is troublesome (there is a globals.pas in the main project too) - it is glowballs.pas now.


      • 2013-11-18 : color on SVF filter outs is wrong - blue instead of red - changed that
      • 2013-11-18 : audio in does not work - it works, but the level display is wrong - changed that
      • 2013-11-18 : audio in does not work, the input values are garbage, this needed buffering - added buffering