ACCORD R.U.L.E

(Reactive Universal Logic Engine)

(Prototype 3)

This module is in the prototyping and development phase as of summer 2026. As new features are added they will be added here!

12 configurable Input / Output jacks with RGB LED's Dual VCA's or 2 extra Inputs Clock & Reset inputs for sync Panel MIDI I/O for talking to MIDI hardware (TRS type Korg) USB MIDI I/O host for USB MIDI devices / Keyboard USB MIDI I/O as device for PC /  IOS / Linux Run / Stop buttons to start / stop execution, sequencers, etc Modular Level I/O -5 to +5 Volts (-10 to +10) Up to 4 "Formula" blocks to house your Rules / Algorithms Audio rate processing Up to 35 Setups can be saved for instant recall Internal generators: 4 LFO's, 4 Envelopes, 4 Quantizers, 4 Random Generators Four range HW Frequency Counter

What is it??
The R.U.L.E. (formerly What's Next) is a universal CV/Gate/Trigger I/O module that obeys rules that you enter into memory to offer ultimate control around your rack. No matter how big or small a function is assigned the response is predictable and accurate. Along with syntax error-less dropdowns to easily create rules, there is an arsenal of generators included.

For example, if your algorithm is set to simply add the CV input at Jack A with the input at Jack B, with the result at jack C, the inputs and outputs are automatically configured and a 1.00 volt input on A and B with result in 2.00 volts at jack C. Or, perhaps you only want this voltage to update when Jack D has a high on it. A conditional statement in front of the A+B statement will only allow updates to Jack C when Jack D is set to high.

You can probably think of all of the benefits of this right away considering doing this with standard modules would be cumbersome and use up VCA or logic modules that could be used for a  different function. To make things even more interesting, there's also Sequencers, LFO's, Delays, and Envelope generators built in that can be triggered whenever you want, play at any speed, and provide an accurate reproduction of previous sessions every time thanks to flash memory.

One of the first questions I was asked when considering this module a few months ago was "what if you select a different User Program (preset) and outputs become patched to outputs of other modules?". My response was that after a Program (scene?) change, the outputs are all held in a high impedance state while a test for loading on the jacks determines if any are going to collide. This is done with very fast low voltage pulses that couldn't possibly damage another module's output. The LED will flash, in what ever color, and won't be an output until the jack is cleared. 

Below I am adding features as they are included. Below that is the development dates and progress. Please not that this may not be updated until late December as I will be overseas and may not be able to access the website from there due to the political climate

FEATURES
(Dev)

Formula Blocks:
At the moment there are 4 blocks, each of which can contain an algorithm (set of statements) and can hold up to 32 lines. These blocks are always active once the "Run" button is pressed. So any changes on any inputs will follow your rules. There are a number of simple presets to choose from to quickly load a block for a specific function. If you name a block according to it's function, then it will be identifiable to load into a different block or user program. Each block can be named which is shown in the header of the editors always, along with jacks used by this block.
Different types of signals are color coded: red for CV, green for gate/logic, blue for a jack assigned to output a trigger, and orange for everything Midi. Conditionals are white.

Run and Stop buttons
To freeze the states, hit the "Stop" button. This will not release the outputs unless the stop button is held. Outputs are also released when a "user program" is first loaded. Anything running will be stopped appropriately, a sequence will stop, an envelope will complete, an LFO will stop, Midi will complete. Pressing Run while Block editing will show line numbers and Stop will open for a line insert.

Gates invoke logic operators:
If a Gate (i.e. GT.A) is set in a statement then the choices following it with be logic like or V, and Λ, xor(+), drop ↓, or rise ↑ so you don't need to go through a lot of operators in the drop down. A gate GT.x statement makes the associated jack an input, but doesn't limit it to being logic. This means a CV.x can still be used anywhere if it's a combination signal that is desired.
The output that is (eventually) where the result will go, unless it is just to start an internal envelope etc, can also have both CV and gate/trigger at the same time, so one won't block out the other. A use case would be a gate that brings an output to only +3 volts because a CV assigned to the same jack is sitting at -2V effectively allowing through-zero modules to function while others don't on the same output.
Trigger (exclusively  drop ↓, or rise ↑ ) is only handled  in a conditional statement, i.e. IF TR.C↑. To turn an output into a proper trigger pulse, OUTx=TRIG↑ statement is used to set it.

Data type profiling:
If a VARn (in-block local variable) or BUSn is used as a rule line's destination, i.e. BUS2=CV.F÷CV.B, then the variable will become that data type. The declared variable won't be able to be used with opposite types, i.e. OUTD=GT.AΛBUS2 with only GT.x showing (or HI or LO for directly setting OUTD in this case). Initially, an undeclared variable brought to an output will color as CV type (red)
This reduces confusion and clutter in the dropdowns, along with color defining jack letters as you scroll through them, making overall use much easier!

An input jack can be defined differently in the rules, i.e. VAR1=CV.A-2.000 then elsewhere IF GT.A=HIGH, then further IF TR.A↓. It's possible to use the same input for 3 different things. This could be useful in a rare case that a gate is also a 1V/oct CV from a special module or combination above .6 volt (from 1v to 4v): IF TR.A↑;  OUTB=CV.A-1.000 ; OUTC=HIGH ; ENDIF
It could also be used in multiple patches.

Conditional Statements:
As expected conditional statements can be placed before any other statements so that only when the condition is met the rest of the block will execute. For. example.
IF CV.A>1.000V  --> statement(s ) following -->  ELSE CV.A>CV.B  --> statement(s) following. This example tests for both CV.A being greater than one volt and also CV.A being higher the CV.B. If the former is true, the first statement(s) will execute, whereas if only the latter is true, the second  statement(s) will execute.
If two (or more) conditions must be true to cause events to execute: IF CV.A>1.000V  followed by AND  CV.A<2.000V  can be written before events.
Multiple level nesting is possible if needed. ENDIF statement only required if there is a new condition in the same block that is unique. Each block assumes an ENDIF before executing the following block.

Embedded events placed between like statements can be used, but can become complex.
  i.e. IF CV.A>0.000V  OUTB=1.000V  AND CV.A<2.000V  OUTC=1.000V. If CV.A is 3 volts, OUTB=1 volt, but OUTC is unchanged.

"AND", "OR", "XOR", or "NOT" can be inserted between conditionals to logically handle the the two. There can be more than one AND/OR/XOR/NOT, but due to the inconvenience  of situating brackets "(  )" any logical will be interpreted as in series. i.e. c1 AND c2 OR c3 will be seen as (c1 AND c2) or c3, not as c1 AND (c2 OR c3). This can  be fixed by simply ordering the last  part first: c2 OR c3 AND c1.

Complex Algorithms:
For really lengthy or complicated  Blocks, VAR's can be used to swap data around without affecting any outputs. i.e. VAR1=CV.A x LFO2   OUTC=VAR1÷4
For global variables to use the data in other blocks, BUS's can be used.

Built in Generators:
The LFO, Envelope, Random, Quantizers, and Sequencers can be used to eliminate adding a lot or lines to do specific things. The most obvious is the Quantizers, which can be custom set to output certain voltages over a range. The Sequencers are super useful for sequential actions inside or as outputs as they can send signals to the Blocks, panel, or Midi in predictable steps of any size, rate, and cycle counts. For example setting 4 outputs to specific voltages on an event is only 6 lines in a Block, but calling a step in a sequencer could do the same with 3 lines. Translating one voltage into another with a curve could be done with math, but also using a held LFO by indexing a phase like a plotter is much faster and can be dynamic without the heavy math. At audio frequencies a fun DSP could be created this way.

Numeric Interpretations:
For a numeric declaration, 3 types can be used: 0.000v (-5.000 to +5.000 or -9.999 to + 9.999), a voltage accurate numeric value; 000 (-999 to 999), a whole number declaration interpreted as volts or percentage in special cases, and N000 (N000 to N127) as a (Midi, CV) Note declaration. (For example N036 seen as C3 note, or CV voltage 1.000 volts - if global CV offset is -2.000 volts).
Certain numbers are considered as more decimal places, i.e. 0.083 (one semitone) will be seen mathematically as 0.08333 to maintain accuracy. Powers are to several decimal places.
Whole numbers are useful for over 9.999 for math like dividing by 200 etc.

Delays:
Delay statements, i.e. DELAY=1000MS, doesn't prevent other Blocks from executing, rather just delays the execution of "this"  block and the statements following. This could be useful if you wanted a clock-stop to roll a filter a certain way, or levels to drop off etc. using a multed input from the system clock to a Jack. An example might be   CV.B=ENV1OUT   IF TG.A = ↑    DELAY=800MS    ENV1=RUN.  A constant clock keeps resetting delay until there is no clock then the internal ENV1 is triggered. Another use might be just to sequence a series of events, although one of the Sequencers could if the event's are evenly spaced. If not, then delays! I.e.  CV.A=CV.C     IF GT.B=HI      DELAY=200MS    CV.A=CV.C+1.000V     DELAY=300MS    CV.A=CV.C    This would add an octave shifting warble to a VCO on CV.A whenever GT.B is high.

TIME:
Similar to delay but defines update rate of an output in milliseconds to lighten processor load. This can be useful with audio signals whose result doesn't need to be updated at audio rate. The assigned time starts counting down only when the output is written to. i.e. OUTF=TIME:5.000 (5 mS) OUTF=LFO4+3, OUTF will present a steppy LFO pattern.

BUSx Variable stacks:
Normally BUSx is a persistant variable that holds it's value (unlike VARx) from block to block, cycle to cycle. Stacking on a BUS is now possible allowing a single BUSx variable to hold multiple values. The values are recalled using voltage proximity. For example, if the values 1, 2, 3, 4, and 5 are pushed into a BUSx (using BUSx <- [value/input etc.]), then the variable is queried (using special bidirectional arrow symbol) with  a voltage, say 2.4 volts, the returned value would be 2.0 volts as it is closest. This can be used as a simple quantizer at the simplest, but become a powerful fractal generator or even a sequencer. The size of the stack can be defined by pushing a whole number to it rather than a CV decimal. For example:
            BUS2 <- 16 (16 max before wrapping)    BUS2<-1.000    BUS2<-2.000    BUS2<-3.000    BUS2<-4.000    BUS2<-CV.C+4.000    Outputting a value: OUTA=BUS2<->CV.B   
To output all values CV.B needs a ramp 0-5 volts. To output random but octave quantized values, apply noise to CV.B or use RNDx instead of CV.B.

DEVELOPMENT

METHODS AND LEARNING (NEW!)
How to use the R.U.L.E.

Contact: freshnel@freshnelly.com

VIDEOS

Web Design by Yours Truly!  I know it looks like something out of the 90's when a 1 Mb webpage was unacceptably large.
We strive to separate ourselves from energy consuming bandwidth-heavy script, AI, and other wasteful environmental unfriendliness
toward this beautiful blue pearl in space we all call home. I urge you to do the same please. It feels good!

Last Update July 17th 2026