What is?

Envion is an envelope‑first engine for Pure Data (Pd): it drives the read index of stereo buffers through textual sequences of triplets (value, time, delay) sent to vline~.
Each line of a text file represents a complete envelope; switching line means switching gesture.

For years, I explored different systems for handling envelopes dynamically — starting with software like Composer Desktop Project, and later with hardware generators such as Zadar in the Eurorack domain.

Envion - Plugdata version

I would like to emphasize how fascinating the world of envelope dynamics is, and how envelopes can imprint transformative tonal characteristics onto sounds. Out of this research, I developed Envion as a kind of gesture generator.

I soon realized that the most flexible way to manage thousands of segments was to use plain-text databases containing the necessary information. From there, I created the Dynatext system.

At the moment, I am working on formatting textual data from external APIs. In this way, Envion could become a powerful tool for generating thousands of random articulations not only generated from local lists but also from the variable numbers of online APIs.

For example, by drawing on stock market data, weather information, or NASA’s extensive library of APIs — which are incredibly rich and fascinating. Even Co-Star, the app that calculates natal charts, makes wide use of them.

The system is designed for musique concrète/acousmatic music, sound design, and non‑metric writing.

Key idea
Instead of “playing” files, Envion writes trajectories on them through numeric envelopes (dynatext). This enables hyper‑articulated hits, slow morphs, irregular internal delays, and pseudo‑organic behaviors.

At its core, Envion adds an algorithmic layer that keeps the envelope and the sample tightly coupled, preserving coherence while enabling complex, generative transformations.

Inside the repository there is also a version tailored for PlugData. It’s worth noting that this version is significantly more performant: unlike Pd-vanilla, where the audio and GUI share the same thread, PlugData (built on JUCE) separates the audio engine from the graphical interface. This reduces overhead, prevents dropouts when interacting with the patch, and makes real-time processing smoother. The JUCE-based architecture also improves GUI responsiveness, event handling, and CPU scheduling, resulting in noticeably faster and more stable performance, especially on older machines.

Dependencies: Cyclone · ggee · ceammc · else · simplex (for 3D scope) | audiolab

Using Envion

As a procedural environment, in most cases it is sufficient to load a sample, record the output for several minutes, and then select the most interesting portions of the generated audio.

1. Load a sample into the main buffer.
2. Enable Random Terna (checkbox below the Dynatext Cloud).
3. Enable Random List (central checkbox).
4. Record the output for several minutes.
5. Select the most significant sections of the recorded audio.

This approach highlights Envion’s nature: it is not about “playing” directly, but about generating emergent sonic material from which fragments can be extracted for composition.

Ultra‑stereo material is recommended for this kind of application. When loading and mirroring mono material, activate Nuke on alternate channels of the matrix mixer to emphasize differences between left and right arrays, widening the stereo field.

First Steps with included audio materials

To start experimenting, try loading the file:

/audio/env_0001.wav

This reel was created specifically for Envion using my modular synthesizers (Orthogonal Devices ER‑301, Morphagene, and several Low Pass Gates). It was then reamped — played back through speakers and re‑recorded in the room — to capture the original ambient nuances of the space.

The result is a material that embodies a contrast:

• Surreal gestures generated by modular synthesis.
• Immersed within a real acoustic environment that imprints its own depth and imperfections.

This interplay between the synthetic and the real, between algorithmic articulation and spatial resonance, is at the core of Envion’s aesthetic exploration.

Procedural Randomization Automation

By enabling both checkboxes, Envion activates a procedural randomization process that automatically draws from 19,000 pre‑defined triplets and applies the X factor to each segment of the terna, imposing its own time‑stretch and creating the sonic gesture.

• Random Terna: continuously loads text files from the /data folder (each file ≈ 1,000 envelopes/triplets).
• Random List: randomly selects one of the 1,000 available lists.

This combines automatic loading and random selection, producing an ever‑changing and potentially infinite stream of events.

The patch may look intimidating at first, but it is intentionally left “alive” (with formulas and functions visible) to encourage exploration. Once you learn the few basic operations (keys 1–5 and the space bar, enabled via a flag), it is often best to record the output to capture unique articulations that are hard to reproduce exactly.

Freeze and Stretch

Stereo Behavior and Enhanced Aggression — NUKE

The Nuke module processes the left and right channels with slight differences in the filter and clipping stages. These micro‑variations introduce phase shifts and asymmetries between L and R, resulting in:

• Stereo widening: L and R are no longer identical, creating a broader image.
• Perceptual instability: small discrepancies cause a lively, shifting space.
• Enhanced aggression: distortion artifacts differ per channel, yielding a wider, noisier stereo field.

This design makes Nuke not only a distortion stage but also a stereo expander through destruction. The contrast between similar but non‑identical processing of L and R gives the module strong spatial depth.

The concept of Terne

One of the central elements of Envion is the use of terne (triplets of numerical values). Each terna defines the behavior of a sound fragment through three main parameters:

1. Duration – relative or absolute time of the event (in ms or scaling factor).
2. Amplitude – the signal level, which can be constant or shaped by an envelope.
3. Offset / Position – the reading point or starting position of the fragment within the sample.

Examples of terne

0.452 80 0 ; → 452 ms duration, amplitude 80, offset at start of sample
0.210 45 600 ; → 210 ms duration, amplitude 45, offset 600 ms into the sample
0.879 100 1280 ; → 879 ms duration, full amplitude, offset 1280 ms
      

Semantic Class – List Validation and Categorization

The patch duration_flag_800.pd implements a basic semantic check for incoming lists (vline‑style). It ensures structural validity and assigns each list to a category before it is passed on.

Step‑by‑step logic

1. Input (inlet) A list in vline~ format enters the patch (usually a triplet: duration – amplitude – offset).
2. Length check (list length) — at least 3 elements; otherwise flagged as invalid.
3. Splitting and unpacking — extract the first three values (unpack f f f), first is duration.
4. Duration test (moses 500) — < 500 ms → percussive; ≥ 500 ms → hybrid.
5. Routing — invalid lists discarded; valid ones tagged and forwarded.

This acts as a semantic filter: it checks structural validity, then classifies by duration so Envion can route lists by temporal behavior.

Quick Start

1. Load a list from Dynatext Cloud (or select a local .txt in data/).
2. Browse a sample (WAV) and assign it as the playback buffer.
3. Turn on DSP and explore.

• Use the manual triggers and sliders to test sequences.
• Adjust the stretch factor to compress/expand time.
• Try the ready‑made presets (bottom area).

Timebase & $0-factor

The timebase module retrieves the buffer duration (samples → milliseconds), exposes it as $0‑durata, and calculates $0‑factor for the global stretch of envelopes.

// from samples to milliseconds (44.1 kHz)
expr round((($f1 * 1000.) / 44100) * 100) / 100
      

• $0‑factor applies to times of each segment.
• Not mandatory when using terne as parameter modulations (e.g., FM resonance, filter index, temporal stretching).

Original‑speed playback: 0, <array_size> <durata_ms> — scans the entire buffer in durata_ms at constant speed.

Workflow

1. Load a sample → openpanel ~ soundfiler into sampletabL/R. If mono, use Mono→Stereo (copy L→R).
2. Load an envelope library → text define/get. Each line = one terna. Select or randomize.
3. Play → autoplay or manual keys: KEY1–4 (strike, original‑speed, stop, retrigger).
4. Record → from AUDIO RECORDER block.

Lists of Terne (1000 envelopes each — total 19k)

• default.txt — neutral baseline.
• perc.txt — fast attacks, short decays.
• vline_perc_1/2 · vline_ultra_perc_3.txt — percussive variants from soft to extreme.
• zadar_style_4triplets.txt — complex, four‑way triplet structures.
• complex_drone_plain.txt — long static drones.
• complex_percussive_plain.txt — articulated rhythmic envelopes.
• emf_interference.txt — glitchy, fragmented shapes.
• drone.txt — extended continuous textures.
• unstable-metro.txt — irregular micro‑timing.
• buchla.txt — organic West‑Coast‑style curves.
• sharpy.txt — sharp transients.
• relaxed.txt — slower, softened curves.
• random_delayed_perc.txt — hits with random delays.
• vactrol.txt — LPG‑like natural A/D.
• polyrhythm.txt — multi‑layered offsets.
• bounded_kickdrum.txt — punchy, short sustain.
• terne_1000_fadeout.txt — progressive fadeouts.

Library formatting

1 0.0 0.58 19 0.8 22 29 1 25 41; 0.7 120 0.0 38 80;

• Line 1 = 4‑segment envelope
• Line 2 = 2‑segment envelope. Avoid all‑zero lines (silence).

Autoplay & Manual Player

• Autoplay: a metro drives text get; last strike duration can trigger next step (END listener).
• Manual:
  • KEY1 = strike
  • KEY2 = original‑speed
  • KEY3 = stop
  • KEY4 = retrigger

Smart concatenation: internal delays in terne allow irregular patterns without reprogramming the metro.

Playback Engine

• tabread4~ sampletabL/R — 4‑point interpolation, indexed by vline~
• *~ / pow~ — amplitude control + shaping
• snake~ — stereo/multichannel routing
• safety — clip~ headroom

Note: tabread4~ never stops until index=0 or out of buffer. For immediate stop: send clear/stop to vline~, or drop amp to 0.

Quick Play & Algorithmic Drum Machine

Manual Strike Mode

• Load any list from the Dynatext Cloud.
• Assign a sample (short percussive ones work best).
• Use KEY‑1 (Manual Strike) to trigger individual gestures. Each line becomes a distinct hit.

This simple workflow turns Envion into an algorithmic drum machine: browse different lists and strike manually to generate unique percussive articulations and irregular rhythms.

Tips & Tricks

• Pair short samples (kicks, snares, metallic hits) with percussive lists (perc.txt, random_delayed_perc.txt).
• Try drone/long lists on short samples for stutters and stretched hits.
• Map envelopes to parameter modulation (filters, FM index) instead of playback.
• Alternate between manual strike and autoplay to balance control and emergence.
• For drum‑like grooves, use Random List + Random Terna and keep sample ≤ 500 ms.