Total Serialism Machine — User Guide

Algorithmic audio segmentation and reordering inspired by post-Webern total serialism: creates pointillistic textures through systematic control of pitch, duration, amplitude, and spatialization.

Author: Shai Cohen Affiliation: Department of Music, Bar-Ilan University, Israel Version: 0.1 (2025) License: MIT License Repo: https://github.com/ShaiCohen-ops/Praat-plugin_AudioTools

Contents:

What this does Quick start Serialism Theory Presets & Styles Parameters Applications

What this does

This script implements total serialist audio processing — deconstructing a source sound into a series of events whose parameters (timing, duration, pitch, amplitude, panning) are controlled by mathematical series and transformations. Inspired by the post-Webern serialist composers (Boulez, Stockhausen, Babbitt), this machine applies rigorous organizational principles to create complex, pointillistic textures from any audio source. Events are extracted, transformed, and reordered according to serial procedures, resulting in precisely controlled yet perceptually rich sonic structures.

Key Features:

6 Compositional Presets — From Webern-style pointillism to statistical fields
Serial Transformations — Inversion, retrograde, rotation operations
Multi-Parameter Control — Independent series for timing, duration, pitch, gain, pan
Event Sorting & Ordering — Systematic temporal arrangement
Granular Processing — Micro-event manipulation capabilities
Spatial Serialism — Panning controlled by series values

What is Total Serialism? Developed by post-WWII composers extending Schoenberg's twelve-tone technique, total serialism applies serial organization to all musical parameters: not just pitch, but also duration, amplitude, articulation, and timbre. Pioneered by composers like Pierre Boulez, Karlheinz Stockhausen, and Milton Babbitt, this approach creates music where every aspect is predetermined by mathematical series. Characteristics: (1) Parameter independence: Each dimension controlled by its own series. (2) Systematic transformation: Operations like inversion, retrograde applied to series. (3) Pointillistic texture: Isolated events rather than continuous lines. (4) High complexity: Perceptually dense despite systematic organization. (5) Objective structure: Compositional decisions removed from subjective intuition. This script adapts these principles to audio signal processing.

Technical Implementation: (1) Series generation: Create numerical series (arithmetic, permutation, or 12-tone) of user-defined length. (2) Transformations: Apply inversion (mirroring), retrograde (reversal), rotation (cyclic shift). (3) Normalization: Scale series to 0–1 range for parameter mapping. (4) Event generation: For each event (1 to num_events): Map series values to parameters (timing, duration, source position, pitch, gain, pan), Extract segment from source, Apply pitch shift via resampling, Apply gain, Apply stereo panning, Apply fade envelope. (5) Temporal sorting: Sort events by their assigned timing values. (6) Concatenation: Assemble events with gaps into final output. The result is a systematic yet complex audio texture where all parameters derive from serial procedures.

Quick start

In Praat, select exactly one Sound object (mono or stereo).
Run script… → total_serialism_machine.praat.
Choose Preset: Start with "Pointillism (Webern-style)" for classic sound.
Set series_length (typically 12 for dodecaphonic, but can be any number).
Choose series_type: Arithmetic (1..N), Permutation (custom), or 12-tone row.
For Permutation, enter comma-separated values in series_values.
Enable use_inversion and/or use_retrograde for transformations.
Set num_events (24-80 depending on density desired).
Adjust min_event_ms and max_event_ms for event durations.
Set gap_between_events_ms for temporal spacing.
Configure pitch range in cents (±200 typical).
Click Apply to process while keeping form open, or OK to process and close.

Quick tip: Start with "Pointillism" preset for classic Webern-style sparse textures — short events (80-250ms), wide pitch range (±400 cents), noticeable gaps. Use "Granular Texture" for dense micro-soundscapes — many short events (50-150ms) with small gaps. Try "Transformational" for extreme effects with inversion and retrograde enabled. For traditional serialism, use series_type = "12-tone row" with series_length = 12. The series_values field accepts comma-separated numbers for custom permutations. Enable visual feedback by watching the Info window during processing. Output is automatically normalized to prevent clipping.

Important: SOURCE MATERIAL DURATION — Longer sources provide more extraction possibilities. Very short sources (< 2 seconds) limit event diversity. Pitch extremes: Values beyond ±600 cents (> tritone shift) may cause artifacts. Event density: High num_events with small gaps creates overlapping textures (intentional in "Statistical Field"). Gap timing: Events are sorted by series-derived timing values, then spaced with fixed gaps — this creates irregular rhythmic patterns. Parameter interdependence: Different parameters use different positions in the series (offset by i+1, i+3, etc.). Mono conversion: Stereo sources are converted to mono before processing, then spatialized via panning series. Real-time feedback: Processing displays progress in Info window — large num_events may take time.

Serialism Theory

Core Serialist Principles

🎼 Fundamental Concepts

Series as Organizational Matrix: Numerical sequences control all parameters

Parameter Independence: Timing, pitch, duration, amplitude each get own series

Systematic Transformation: Mathematical operations generate variety

Objective Structure: Compositional decisions based on rules, not intuition

Perceptual Complexity: Simple rules create rich, intricate textures

Series Types and Construction

Three fundamental series types:

# 1. ARITHMETIC SERIES (1..N) Series: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 Normalized: 0.00, 0.09, 0.18, 0.27, 0.36, 0.45, 0.55, 0.64, 0.73, 0.82, 0.91, 1.00 Use: Simple linear progression # 2. PERMUTATION SERIES (custom) Input: "0,10,7,11,3,8,1,9,2,5,6,4" Series: 0, 10, 7, 11, 3, 8, 1, 9, 2, 5, 6, 4 Normalized: 0.00, 0.91, 0.64, 1.00, 0.27, 0.73, 0.09, 0.82, 0.18, 0.45, 0.55, 0.36 Use: Custom ordering, derived from existing compositions # 3. 12-TONE ROW (classic example) Built-in: 0, 10, 7, 11, 3, 8, 1, 9, 2, 5, 6, 4 Normalized: 0.00, 0.91, 0.64, 1.00, 0.27, 0.73, 0.09, 0.82, 0.18, 0.45, 0.55, 0.36 Use: Traditional serialism, pitch-class sets # Normalization formula: normalized[i] = (series[i] - min(series)) / (max(series) - min(series)) # Results in 0–1 range for parameter mapping

Serial Transformations

🔄 Mathematical Operations

Inversion (Mirroring): Values reflected around midpoint

Retrograde (Reversal): Series played backward

Rotation (Cyclic Shift): Series shifted circularly

Combinations: Retrograde-inversion, rotated-retrograde, etc.

Preservation of Intervals: Relationships maintained under transformation

Transformation Algorithms

Mathematical implementations:

# INVERSE TRANSFORMATION # Reflection around midpoint of range min_val = minimum(series) max_val = maximum(series) midpoint = (min_val + max_val) / 2 inverse[i] = min_val + max_val - series[i] # Equivalent to: inverse[i] = 2×midpoint - series[i] Example: series = [1, 3, 5, 7, 9] min=1, max=9, midpoint=5 inverse = [9, 7, 5, 3, 1] # Mirror image # RETROGRADE TRANSFORMATION # Simple reversal retrograde[i] = series[length - i + 1] Example: series = [1, 3, 5, 7, 9] retrograde = [9, 7, 5, 3, 1] # ROTATION TRANSFORMATION # Circular shift by k positions rotated[i] = series[((i-1 - k) mod length) + 1] Example: series = [1, 3, 5, 7, 9], k=2 rotated = [7, 9, 1, 3, 5] # Shift left by 2

Multi-Parameter Mapping

Distributing Series Across Dimensions

Each parameter uses different positions in the series:

# Parameter mapping offsets (circular through series) FOR event i: # Timing (sorting order) series_i = ((i - 1) mod series_length) + 1 time_val = normalized_series[series_i] # Duration (offset by +1) dur_series_i = ((i + 1 - 1) mod series_length) + 1 dur_val = normalized_series[dur_series_i] event_dur = min_dur + dur_val × (max_dur - min_dur) # Source position (offset by +3) source_series_i = ((i + 3 - 1) mod series_length) + 1 source_val = normalized_series[source_series_i] source_pos = source_val × (source_duration - event_dur) # Pitch shift (offset by +4) pitch_series_i = ((i + 4 - 1) mod series_length) + 1 pitch_val = normalized_series[pitch_series_i] pitch_cents = min_pitch + pitch_val × (max_pitch - min_pitch) # Gain (offset by +6) gain_series_i = ((i + 6 - 1) mod series_length) + 1 gain_val = normalized_series[gain_series_i] gain_db = -12 + gain_val × 12 # -12dB to 0dB range gain_linear = 10^(gain_db / 20) # Pan position (offset by ×2) pan_series_i = ((i × 2 - 1) mod series_length) + 1 pan_pos = normalized_series[pan_series_i] # 0=left, 1=right

Temporal Sorting Algorithm

Creating Rhythmic Structures from Series

Event ordering based on series values:

# Step 1: Assign timing values from series FOR i FROM 1 TO num_events: series_i = ((i - 1) mod series_length) + 1 event_time[i] = normalized_series[series_i] event_index[i] = i # Step 2: Sort events by timing value (bubble sort) FOR i FROM 1 TO num_events - 1: FOR j FROM i + 1 TO num_events: IF event_time[event_index[j]] < event_time[event_index[i]]: # Swap indices temp = event_index[i] event_index[i] = event_index[j] event_index[j] = temp # Step 3: Process in sorted order FOR pos FROM 1 TO num_events: i = event_index[pos] # Original event number # Process event i (now at temporal position pos) # Result: Events occur in order of series-derived timing values # Fixed gaps inserted between events in final concatenation

Complete Processing Pipeline

SETUP: Select Sound object (source) Validate: exactly one sound selected SERIES CONSTRUCTION: IF preset ≠ Custom: apply preset parameters Build series according to series_type Apply transformations (inversion, retrograde, rotation) Normalize series to 0–1 range EVENT GENERATION: FOR i FROM 1 TO num_events: # Calculate all parameters from series timing = normalized_series[((i-1) mod L) + 1] duration = map(normalized_series[((i) mod L) + 1], min_dur, max_dur) source_pos = map(normalized_series[((i+2) mod L) + 1], 0, source_dur-duration) pitch_cents = map(normalized_series[((i+3) mod L) + 1], min_pitch, max_pitch) gain = map(normalized_series[((i+5) mod L) + 1], -12dB, 0dB) pan = normalized_series[((i×2-1) mod L) + 1] # Extract and process segment segment = Extract part: source_pos, source_pos+duration IF stereo: Convert to mono Apply gain: segment × gain_linear IF pitch_cents ≠ 0: Resample for pitch shift Apply fade envelope (5ms) Apply stereo panning: left=√(1-pan), right=√(pan) # Store with timing value for sorting event_time[i] = timing event_segment[i] = segment TEMPORAL ORGANIZATION: Sort events by event_time[] Concatenate with fixed gaps between events FOR pos FROM 1 TO num_events: Append event_segment[sorted_index[pos]] IF not last: Append gap_silence(gap_ms) FINALIZATION: Normalize peak to 0.99 Play result Display processing summary

Presets & Styles

Preset 1: Pointillism (Webern-style)

🎵 Classic Serialist Texture

Character: Sparse, isolated events, wide pitch range, noticeable silences

Inspiration: Anton Webern's late works, Op. 27-31

Parameters: num_events=24, min_event_ms=80, max_event_ms=250, gap_ms=150, pitch_range=±400¢

Typical use: Academic serialism, pedagogical examples, abstract textures

Preset 2: Moment Form (Discrete Blocks)

🧱 Segmented Structure

Character: Distinct blocks, moderate density, clear separation

Inspiration: Stockhausen's "Klavierstücke", moment form composition

Parameters: num_events=20, min_event_ms=300, max_event_ms=800, gap_ms=200, pitch_range=±300¢

Typical use: Structural composition, segmented narratives, formal clarity

Preset 3: Granular Texture (Micro-events)

🌫️ Dense Micro-Soundscape

Character: Many short events, small gaps, overlapping textures

Inspiration: Granular synthesis, microsound aesthetics

Parameters: num_events=60, min_event_ms=50, max_event_ms=150, gap_ms=20, pitch_range=±200¢

Typical use: Textural beds, ambient backgrounds, sound design

Preset 4: Transformational (Extreme Ranges)

⚡ Radical Processing

Character: Wide parameter ranges, transformations enabled, dramatic effects

Inspiration: Experimental studio techniques, tape manipulation

Parameters: num_events=40, min_event_ms=100, max_event_ms=700, gap_ms=80, pitch_range=±600¢, inversion=yes, retrograde=yes

Typical use: Experimental music, sound art, extreme processing

Preset 5: Statistical Field (Dense Cloud)

☁️ Mass Texture

Character: Very dense, many overlapping events, statistical distribution

Inspiration: Xenakis' stochastic music, mass phenomena

Parameters: num_events=80, min_event_ms=150, max_event_ms=500, gap_ms=10, pitch_range=±300¢

Typical use: Statistical textures, dense clouds, mass effects

Preset 6: Custom (Manual Settings)

🔧 Full Parameter Control

Character: User-defined across all dimensions

Inspiration: Specific compositional needs, experimentation

Parameters: All values manually adjustable

Typical use: Precise control, specific textural goals, research

Parameters

Preset Selection

Parameter	Type	Default	Description
preset	option	Custom	Behavioral preset (1-6)

Series Configuration

Parameter	Type	Default	Description
series_length	integer	12	Length of control series (typically 12 for dodecaphonic)
series_type	option	12-tone row	Arithmetic, Permutation, or 12-tone row
series_values	sentence	"0,10,7,11,3,8,1,9,2,5,6,4"	Comma-separated values for Permutation type

Serial Transformations

Parameter	Type	Default	Description
use_inversion	boolean	0 (no)	Apply inversion transformation to series
use_retrograde	boolean	0 (no)	Apply retrograde transformation to series
rotation	integer	0	Rotate series by this many positions

Event Structure

Parameter	Type	Default	Description
num_events	integer	30	Total number of events to generate
min_event_ms	positive	200	Minimum event duration in milliseconds
max_event_ms	positive	600	Maximum event duration in milliseconds
gap_between_events_ms	positive	50	Silence gap between events in milliseconds

Pitch Range

Parameter	Type	Default	Description
min_pitch_cents	integer	-200	Minimum pitch shift in cents (-600 to 0)
max_pitch_cents	integer	200	Maximum pitch shift in cents (0 to +600)

Internal Derived Parameters

Parameter	Type	Description
normalized_series[]	array	Series values normalized to 0–1 range
event_time[]	array	Timing values for each event (from series)
event_index[]	array	Sorted event indices after temporal ordering
min_event_s, max_event_s	real	Duration bounds converted to seconds
gap_s	real	Gap duration converted to seconds

Applications

Academic Composition

Use case: Teaching serialist principles through audible examples

Technique: Use 12-tone row with inversion/retrograde transformations

Example: Demonstrate how series control creates perceptible structure

Sound Design

Use case: Creating complex, evolving textures for media

Technique: "Granular Texture" or "Statistical Field" presets

Example: Sci-fi interfaces, magical effects, transitional sounds

Algorithmic Music Generation

Use case: Generating structured yet complex musical materials

Technique: Random series generation with systematic transformations

Workflow:

Generate random permutation series
Apply different transformations to create families
Map to different source materials
Create larger structures through systematic variation

Analytical Tool

Use case: Studying serialist compositions through re-synthesis

Advantages:

Hear the effect of specific series
Isolate parameter controls
Compare different transformation strategies
Understand perceptual consequences of serial organization

Example: Reconstructing Webern's pitch series as audio events

Experimental Audio Processing

Use case: Radical transformation of source material

Technique: "Transformational" preset with extreme ranges

Example: Deconstructing speech into abstract pointillistic textures

Application: Sound art, electroacoustic composition, experimental radio

Practical Workflow Examples

🎓 Teaching Serialism (Music Theory Class)

Goal: Demonstrate 12-tone technique audibly

Settings:

Preset: Pointillism (Webern-style)
Series type: 12-tone row
Series length: 12
Transformations: Inversion=Yes, Retrograde=No
Source: Piano chord
Num_events: 24 (series × 2)

Result: Clear audible demonstration of serial organization

🎬 Sci-Fi Sound Design (Film/TV)

Goal: Create complex interface/technology sounds

Settings:

Preset: Granular Texture
Series type: Permutation with custom values
Source: Synthesizer glissando
Num_events: 60
Event duration: 50-150ms
Gap: 20ms (creates overlapping texture)

Result: Dense, complex texture suggesting advanced technology

🔬 Research Tool (Music Cognition)

Goal: Generate stimuli for perception studies

Settings:

Preset: Custom
Series: Controlled permutations
Parameters: Systematically varied across conditions
Documentation: Full parameter recording

Result: Reproducible, systematically varied audio stimuli

Advanced Techniques

Series design strategies:

Intervallic series: Design based on specific interval patterns
Multiple series: Run script multiple times with different series
Nested transformations: Apply transformation chains (P, R, I, RI)
Series concatenation: Create longer series by joining multiples
Parameter-specific series: Different series for different parameters

Traditional serialist practice often uses prime (P), retrograde (R), inversion (I), and retrograde-inversion (RI) forms

Source material optimization:

Harmonically rich: Complex spectra provide more variation
Dynamic variation: Sources with amplitude changes add interest
Timbral variety: Different attack/sustain characteristics
Stereo sources: Provide spatial interest before panning
Duration: Longer sources allow more extraction positions

Optimal sources: piano chords, string sustains, percussion hits, environmental sounds

Troubleshooting Common Issues

Problem: Output contains long silences or sparse events
Cause: Series values clustered at extremes, or gap between events too large
Solution: Check series distribution, reduce gap_between_events_ms, increase num_events

Problem: Events sound "choppy" or artificial
Cause: Very short event durations, abrupt fades
Solution: Increase min_event_ms, use longer fade times, choose smoother source material

Problem: Pitch shifts cause artifacts or distortion
Cause: Extreme pitch values (±600¢ or more), resampling artifacts
Solution: Reduce pitch range, use higher quality resampling, pre-filter source

Problem: Stereo image unbalanced
Cause: Series values clustered in panning range
Solution: Check pan_pos distribution, adjust series values, enable uniform distribution

Historical Context & References

Key Serialist Composers

📜 Historical Development

Anton Webern (1883-1945): Pointillistic texture, extreme economy

Pierre Boulez (1925-2016): Total serialism, "Structures I"

Karlheinz Stockhausen (1928-2007): Electronic serialism, moment form

Milton Babbitt (1916-2011): American serialism, combinatoriality

Luciano Berio (1925-2003): Serialism combined with other techniques

Technical Extensions

Beyond Traditional Serialism

Potential script extensions:

# 1. MULTIPLE SERIES LAYERS # Different series for different parameter groups pitch_series = [P1, P2, ..., Pn] duration_series = [D1, D2, ..., Dn] amplitude_series = [A1, A2, ..., An] # 2. SERIES COMBINATORICS # Generate all forms: P, R, I, RI prime = [p1, p2, ..., p12] retrograde = reverse(prime) inversion = invert(prime) retrograde_inversion = reverse(invert(prime)) # 3. SERIES MULTIPLICATION # Boulez's technique in "Structures I" multiplied[i] = (series1[i] × series2[i]) mod 12 # 4. PROBABILISTIC SERIALISM # Xenakis-style stochastic distribution # Series values determine probabilities, not fixed values event_probability[i] = normalized_series[i] IF random() < event_probability[i]: include_event()