F_CODEZ – Text, Code and Note Sequencer

F_CODEZ is a trigger and pitch generator that turns text-like input into rhythmic patterns and melodic control voltages. It can interpret plain words, encoded data, symbolic rhythm strings, Braille-style dot patterns, or direct note names, and converts them into structured timing and pitch events. In addition to the main PITCH and GATE outputs, F_CODEZ includes three flexible assignable event outputs, allowing specific elements of the sequence such as accents, end-of-cycle triggers, short events, long events, rests, ratchets, letter gaps, word gaps, or tagged drum-style events to be routed separately. This makes F_CODEZ both a creative sequencer and a powerful structural tool inside modular patches.

Core Idea

F_CODEZ works in three main stages: MODE, MAP, and QUANT. MODE defines how the input text is translated into rhythmic events. MAP defines how those events receive a pitch identity. QUANT translates that identity into actual musical pitch. Together these three stages form a flexible pipeline where the same input text can produce radically different rhythmic and melodic results depending on configuration.

Editing the Text Field

The text field is the source for everything the module plays, but it must be used in the intended way. To edit the content, double-click inside the text field. After typing, click outside the text field to leave edit mode and make the new text active for playback. In other words, editing and playback are separated: double-click to enter text, click outside to commit the text back to the player. If you stay inside edit mode, you are still editing the source rather than running the newly entered material.

MODE – Event Generation

MODE determines how the text field is interpreted and converted into timing events. This defines the rhythm and structure of the sequence.

MORSE converts text into Morse code timing. Dots become short gates, dashes become long gates, and spacing creates structured rests. This is ideal for turning language into rhythmic code patterns. Morse mode is expressive and phrase-like rather than strictly grid-based, so it often feels organic and human rather than machine-quantized.

BINARY converts each character into a 7-bit binary representation. Each bit becomes a step, producing machine-like rhythmic sequences derived from digital encoding. Binary mode is tight, repetitive, and good for mechanical or clock-driven textures.

CUSTOM allows direct symbolic rhythm programming. You define gates, rests, accents, ratchets, separators, and tagged events manually. This is the most precise and performance-oriented mode, and it is the best choice when you want exact rhythmic control rather than text interpretation.

TERNARY uses the values 0, 1, and 2 to define rest, short gate, and long gate behavior. This creates compact number-based rhythm strings that are easy to type and easy to repeat.

HEX interprets hexadecimal symbols from 0 to F. Different values produce different event types such as rests, short gates, medium gates, long gates, and ratchets. This mode is compact, fast to type, and powerful for dense rhythmic coding.

NOTE reads note names directly, such as C4, Eb4, G#3, or R for rest. In this mode the text field behaves like a direct note-entry sequencer rather than a code converter. NOTE mode is the most immediate melodic mode and is ideal when you want explicit musical pitch input.

BRAILLE converts each supported character into a fixed 6-step dot pattern. Active dots become gates and inactive dots become rests. Because Braille patterns are fixed-length, this mode is tighter and more grid-like than Morse, making it very useful for structured rhythmic sequencing while still keeping a language-derived feel.

MAP – Pitch Identity

MAP determines how letters or symbols are converted into a raw pitch index before musical quantization happens. MAP does not create rhythm. The rhythmic structure always comes from MODE. MAP only affects the pitch identity assigned to events that already exist because of the selected MODE.

LINEAR assigns a straightforward rising index to letters and symbols. This is the most direct and predictable mapping and usually produces the clearest relationship between the written input and the resulting melodic contour.

WRAP12 folds the pitch index into a repeating 12-step cycle. This keeps melodic motion tighter, more cyclic, and often more immediately musical because pitch identities repeat more quickly.

ASCII uses character codes as the pitch source. This usually produces wider jumps and less obviously musical motion, which makes it useful for more digital, mechanical, coded, or experimental melodic behavior.

MORSE derives the pitch index from the shape of the Morse pattern itself rather than just from the letter identity. This ties pitch more closely to rhythmic symbol structure, so letters with different Morse shapes can also create different melodic behavior even when the original text is simple.

ENIGMA applies an internal rotor-style letter transformation before pitch identity is derived. This means repeated letters do not necessarily behave like repeated pitch sources in the normal sense. ENIGMA does not change the rhythm created by MODE, but it can make the pitch layer feel more coded, transformed, less literal, and more internally evolving than the visible text suggests.

Important about MAP

MAP does not change timing, spacing, gate length, ratchets, or event structure. If two settings produce the same rhythm but a different melodic contour, the difference is caused by MAP and QUANT, not by MODE. In other words: MODE decides when events happen, MAP decides what pitch identity those events carry.

MAP in NOTE Mode

MAP is most relevant when you are using character-based modes such as MORSE, BINARY, CUSTOM, TERNARY, HEX, or BRAILLE. In NOTE mode, the written note names already define pitch directly, so MAP has little or no practical effect there. NOTE mode behaves more like a direct note-entry sequencer than a character-mapping system.

QUANT – Musical Translation

QUANT determines how the raw pitch index from MAP is turned into actual pitch voltage. This is the musical interpretation stage.

OFF disables meaningful pitch generation. Rhythmic output still works, but pitch is no longer actively translated in a useful musical way.

SCALE maps the incoming pitch index onto a scale-based structure. This keeps output musically constrained and is often the most useful setting when you want melodic results without excessive chromatic movement.

CHROM maps the pitch index chromatically in semitone steps. This gives the most direct and complete pitch translation.

OCT reduces motion to octave-based behavior. This produces broader, more stable pitch movement.

FIFTH emphasizes root-and-fifth style relationships, creating a more open and harmonically spacious result.

QUANT is especially powerful when combined with different MAP settings. For example, a wide or chaotic mapping can be musically tamed by SCALE, while a tighter mapping can become more exact and technical in CHROM. OCT and FIFTH are especially useful when you want strong pitch identity without excessive melodic clutter.

How MODE, MAP and QUANT Work Together

The easiest way to think about F_CODEZ is as a three-stage chain. MODE decides what events exist and how long they last. MAP decides what pitch identity is attached to those events. QUANT decides how that pitch identity is translated into musical voltage. A single text string can therefore produce very different results depending on how these three controls are combined. For example, MORSE with LINEAR and SCALE can create melodic coded phrases, while HEX with ASCII and CHROM can create more angular and digital melodic behavior. BRAILLE with WRAP12 and FIFTH can create tight, repeating coded grooves. MORSE or CUSTOM with ENIGMA can create evolving melodic behavior from otherwise repetitive text. NOTE mode is different because the note names already contain direct pitch information, so the module behaves more like a compact text-entered note sequencer.

Transport and Timing

F_CODEZ can run from its own internal timing or from an external clock. The CLK input advances the sequence when external clocking is used. The RUN input acts as a transport gate input. The RESET input restarts the sequence from the beginning. Internally, the module can also run from its own timing system when no external clock is used. The panel RUN control allows manual start and stop behavior when no external run signal is present.

Speed and Units

The SPEED control is expressed in units per second. A unit is the fundamental timing block used internally by F_CODEZ. Different modes divide input text into units in different ways, so SPEED directly determines how quickly the sequence advances through those units. Lower values create slow, spacious patterns. Higher values create faster, more mechanical or more intense results. Because SPEED is shown in units per second rather than as an arbitrary knob percentage, it is easier to understand timing relationships and to type in exact values.

Text Display and Code View

The canvas shows the currently active code behavior in a visual form. In character-based modes it shows the current character together with surrounding context and the currently active code fragment. In NOTE mode it shows the current note token together with surrounding note context, so you can see where the sequence is at any given moment. The text field below the canvas is the editable source area where you type the text, code, symbols, or note names that drive the module. Remember that new text becomes active for the player only after you leave edit mode by clicking outside the text area.

Main Controls

MODE selects the parsing system used for the text field. This is the main rhythmic behavior selector.

MAP selects how pitch indexes are derived from characters or symbols. This only affects pitch meaning, not rhythm generation.

QUANT selects how those pitch indexes are converted into musical pitch.

SPEED sets the internal playback rate in units per second when no external clock is connected. This directly controls how fast the sequence advances through its events.

GATE LENGTH controls how long each gate stays high relative to its step duration. Lower values produce shorter, more percussive triggers, while higher values create longer sustained gates.

SPACE adds extra spacing between events. This effectively stretches rests and can make patterns feel more sparse, more separated, or more phrase-like. SPACE is useful for groove shaping, but it is not a strict synchronization tool.

PROB controls the chance that a generated gate will actually occur. At 100% all playable events fire as programmed. Lower values introduce variation by randomly skipping gate-producing events, which is especially useful for creating evolving or less predictable patterns.

ROOT sets the base pitch used by the quantization system.

RANGE defines how many octaves the pitch mapping can span.

TRANSPOSE shifts the resulting pitch up or down in semitones after mapping and quantization.

LOOP determines whether the sequence restarts automatically when it reaches the end. When disabled, playback stops advancing at the final event.

Modulation Inputs

F_CODEZ includes six assignable modulation inputs. Each modulation input can be assigned to a selectable target such as speed, gate length, spacing, probability, transpose, root, or range. This allows the same text source to become much more dynamic during playback. Because the modulation inputs are freely assignable, the module can be used as a static sequencer, a performance-oriented generator, or a moving generative source.

Main Outputs

PITCH outputs pitch CV derived from the current event. GATE outputs the main rhythmic gate pattern. These two outputs represent the central melodic and rhythmic behavior of the module.

Assignable Event Outputs

In addition to PITCH and GATE, F_CODEZ includes three assignable event outputs. These are not fixed-purpose outputs. Instead, each one can be set independently to follow a selected event type. This allows a single code pattern to drive multiple layers in a patch.

Each event output can be assigned to one of the following sources: OFF, ACCENT, EOC, SHORT, LONG, REST, RATCHET, LETTER, WORD, KICK, SNARE, or HAT.

ACCENT outputs a short trigger when an accented event occurs. EOC, meaning End Of Cycle, outputs a short trigger whenever the sequence reaches the end of its cycle. SHORT follows short events such as dots or one-unit gates. LONG follows longer gate events such as dashes or multi-unit gate steps. REST outputs a trigger at the beginning of rest events. RATCHET follows ratchet events. LETTER follows character boundaries where relevant. WORD follows word or larger phrase spacing where relevant. KICK, SNARE, and HAT follow tagged K, S, and H events in CUSTOM mode.

These assignable outputs make it possible to drive several sound sources or structural processes from one text sequence. For example, one output can follow SHORT events, another can follow LONG events, and another can follow WORD boundaries. Or in drum-style CUSTOM mode, one output can follow KICK, one can follow SNARE, and one can follow HAT.

Morse Mode Input

In MORSE mode, standard text is translated into Morse timing. Letters and numbers are converted into dot-and-dash patterns. Dots create short events. Dashes create long events. Spacing between symbols, letters, and words becomes structured rests. Because Morse contains its own internal spacing rules, it is phrase-oriented rather than purely grid-oriented. This makes it expressive, but it also means it will not always align to rigid musical divisions in the same way as a hand-coded pattern.

Binary Mode Input

In BINARY mode, each character becomes a 7-bit ASCII pattern. This produces highly regular step sequences with a digital feel. Binary mode works especially well with external clocking and tighter rhythmic applications.

Custom Mode Input Symbols

In CUSTOM mode, the text field accepts direct symbolic input. A period can create a short gate. A dash creates a long gate. An underscore creates a short rest. A space creates a longer rest. An exclamation mark accents the next event. A lowercase r creates a two-step ratchet. An uppercase R creates a three-step ratchet. A vertical bar can be used as a separator. In addition, CUSTOM mode supports tagged symbols for drum-style routing: K marks a kick-style event, S marks a snare-style event, and H marks a hat-style event. These are still gate events, but they can also be extracted separately through the assignable event outputs.

This makes CUSTOM mode especially powerful. It can be used as a direct symbolic rhythm language, as a performance sequencer, or as a text-based drum router. For example, a pattern such as K _ H _ S _ H _ can drive one module from the main GATE output while sending separate kick, snare, and hat triggers from the three assignable event outputs.

Ternary Mode Input

In TERNARY mode, only the values 0, 1, and 2 are expected. Zero creates a rest, one creates a short gate, and two creates a long gate. This gives a very compact and efficient way to type tightly controlled patterns.

Hex Mode Input

In HEX mode, characters from 0 to F produce a range of rhythmic behaviors. Lower values tend toward rests or short gates, middle values produce longer gates, and upper values can create ratchet-related behavior. HEX mode is compact, dense, and good for fast coding of energetic patterns.

Note Mode Input

In NOTE mode, the text field accepts note tokens separated by spaces. Standard note letters are supported, including sharps and flats, and octave numbers may be added. R can be used for a rest. This makes F_CODEZ usable as a compact text-driven note sequencer, while still providing gate, event extraction, and cycle behavior from the same engine.

Braille Mode Input

In BRAILLE mode, supported letters and numbers are converted into fixed six-step dot patterns. Active Braille dots become gates and inactive dots become rests. Because every symbol occupies the same basic width, Braille mode is structurally tighter than Morse and often easier to synchronize in clock-based patterns. It is useful for coded grooves that still retain symbolic origin.

About Sync and Clock Relationships

Some modes are naturally more grid-like than others. BINARY, TERNARY, HEX, BRAILLE, and especially CUSTOM are generally easier to align tightly to clock-based patterns. MORSE is more phrase-driven because its spacing rules are based on symbol structure rather than a fixed musical grid. SPACE can change feel and density, but it does not fundamentally turn phrase-based timing into strict meter. If tight alignment is required, external reset and more grid-based modes are often the better choice.

Typical Uses

F_CODEZ can be used as a coded rhythm source, a text-driven trigger sequencer, a melodic phrase generator, a compact note sequencer, a symbolic drum router, or a structural utility for modular patches. It can drive envelopes, sequencers, drum voices, oscillators, quantized melodic patches, or chained events via its assignable event outputs. It is equally suited to experimental code-driven structures and more musical pitch-aware sequencing.

Practical Patch Examples

A simple melodic patch can use PITCH and GATE to drive an oscillator and envelope. A more advanced patch can send SHORT and LONG events to different percussion voices. A CUSTOM drum patch can use K, S, and H tags so that one line of text drives separate kick, snare, and hat layers. A structural patch can use WORD events to reset another sequencer or use EOC to trigger a larger phrase change elsewhere in the patch. An ENIGMA-based patch can keep the rhythmic structure stable while making pitch behavior feel more coded, transformed, or less literally tied to the visible text.

In Practice

If you want rhythm first, start by choosing a MODE and entering text or symbols. Double-click the text field to edit it, type your material, and click outside the field to make that material active. If you also want melody, choose a MAP and then a QUANT behavior. If the result is too chaotic, use SCALE, OCT, or FIFTH. If you want more direct pitch behavior, use CHROM. If you want completely explicit melody, switch to NOTE mode and enter note names directly. If you want strict manual rhythm design, use CUSTOM mode. If you want several layers from one pattern, assign the event outputs to the event types you want to extract. Once the basic sequence works, use the modulation inputs to animate speed, spacing, probability, or pitch behavior over time.

Summary

F_CODEZ is a text-to-sequence engine with three distinct layers: MODE decides how text becomes events, MAP decides how symbols become pitch meaning, and QUANT decides how that pitch meaning becomes music. Around this core, the module adds flexible event extraction through three assignable event outputs, allowing one code pattern to become several simultaneous rhythmic streams. Together these layers allow the same input to behave as rhythm, melody, code, notation, drum logic, or structured control voltage, depending on how the module is configured.