At the heart of NoteWeaver, there're tables that map and decode each
incoming note from an input Keyboard A, Keyboard B, and Guitar x 8 layers.

Note: By clicking on controls, and playing with them, most things in NoteWeaver produce
immediate results that can be quickly figured out. Also, there're mouse hover tips at
the top of the window briefly describing the particular controller functions.

NoteWeaver tables are designed to be large, and comfortable to edit.

Here, Functions are applied, and decode each incoming note.

At the upper right is a chord applied to one note the mouse is hovering over.

At the bottom, you can see all the data in the various layers for the note the mouse is hovering over.

Here's a list of the various Functions each played note can trigger.

While editing, scrolling the mouse selects Functions within the right shown list.

For convenience, high speed editing was (obviously) imperative to implement.

For instance, in the Offsets (and Scales) windows , it's valuable to skew the
numbers in various ways to get incrementing and decrementing values.

Also, it's helpful to edit by Row, Column, All, Function,
Black & White, Black, or White keys only.

One can also, simultaneously edit various layers, if selected, here:

The entire table(s) of a map (or scale) can be shifted, or reversed.

With single mouse clicks, complete tables of data can be instantly
filled into all following layers. The Output Channels can also
auto-increment (from the current layer) by the selected 'By' qty.

Shown here are Offsets that work in conjunction with Functions.

Here, each note of each layer sends it's output to a selection of
256 output port.chans (after getting decoded through scales).

These select which output voice to sound.

On a note-by-note basis, you can link to other layers, in various ways, often depending upon note velocity.

Arp and Echo beats are selected from within a list, or 4x precision beats (beyond that shown) can be built manually, and saved.

Here's an example of guitar note decoding -- 6 strings x 24 notes, each.

Chords are designed by clicking in the Chords tables, with notes, visually, in any Key
desired, by selecting the first cell clicked, and clicking other notes relative to this.

Played Chords are then selected in the KG map Chords tables by number (1-256).

Scales are designed here, in any Key, and Starting position along the octave.

At the bottom right, there's a selection for "Ordered", whereby one can click the
scale notes in any order, and they will be filled in, in the large table, in various orders.

Then, for each layer of each instrument (in the KG Map windows), scales are applied. -- Also transposition.

By the way, the circular scales used in NoteWeaver start with C in the
10:00 position, so the effective black keys of a keyboard are balanced, with
C# and D# symmetrically on the top and F#, G#, and A# symmetrically on the bottom.

Also, clicking in the areas between the white line segments streamlines editing.

The final decoded notes are sent to the output synth voices. The tables to the right
also direct input controller events to the voices in an open-ended fashion.

Editing on the lower Synths maps (also in the smaller Play window table) can be
done by various quantities, and every so often. They can also be ramped
and random Programs (voices) can be selected within a chosen range.

This can be done in real-time, while Echo voices are cycling, for instance.

The upper left table offers rich voice auditioning opportunities to select your favorites.

Each input controller can control up to 8 output controllers, each with their own input and output ranges.

Bends can have independently selectable Up and Down ranges.

Note: This mapping only applies to 7 bit controllers, and 14 bit bend controllers.

If you're using your synth also as an input controller, NRPN
controller data is first sent to NoteWeaver, then it's echoed right
back. This way you can control higher resolution synth variables in real-time.

Most real-time performance is from within the Play window.

Fluid, real-time adjustments to individual scale notes (see lower left colored dots),
complete scales, arps, echos, layering, voices, volumes, pans, mute, beat parameters,
KG maps, etc. can all be made during a performance, like when running an Echo.

 
This is the "Top Map View", which shows input notes on the top keyboard, and output notes on the bottom keyboard.

The Tracks window provides a Piano Roll vertical style view, for
recording and playing back notes and chords through KG Maps.

NoteWeaver does not support audio wav files, nor does it do any type
of music synthesis, or effects, besides it's MIDI note and controller functioning.

The sequencer can send it's final output notes to the Final Output Score window.

These notes are non-editable, here, and are modified within the above Tracks window.

The Setup window's used to set various MIDI ports and other
settings, plus bulk copying of data and tracks between files.

By clicking the Help menu, you're instantly vectored help associated with the last window you were viewing.

For speed, the various names of things can be edited in the Names window.

They can also be edited in place, throughout the program.

In the Colors window, 4 custom color sets can be created, and saved.

From within the Help system, a general NoteWeaver flow chart can be seen.

There's also a Navigation window that pops up when a Nav note function
is triggered. Here, you can quickly vector into other maps, scales, etc.

Then, by clicking the Spokes menu, output
notes can be viewed as notes spiraling inward,




and as Shapes -- Valuable for Music theory understanding:

Augmented chord dots ...................................................................... Diminished chord dots