Как вам такие плагины от ИИ? (11 онлайн)

Gluhov Prod.

Active Member
12 Сен 2011
485
214
43
Тольятти
vk.com
Вроде бы в ту ветку написал)

По поиску подобное не нашел. Наткнулся на чувака, который сделал несколько приборов с помощью ИИ. Все они бесплатные. Как Вам такое - плагин для поиска беслатных плагинов прям на канале Вашей DAW?))



И него есть очень недурно звучащие компрессоры:



И не только:





На удивление, очень не плохие приборы вышли. Я в шоке, сколько сейчас будет нового софта на рынке!!!
 
  • Like
Реакции: yunusmus
повтор, уже и обсудили и потестировали )
 
Вот почему поиск так плохо работает? Я по разному поискать попробовал) Удалите тогда тему, пожалуйста!
 
@deplexer,
бегло глянул видео, так похоже что никто ничего не мерял и не хакал, а просто сказал ИИ сделать инспайерд бай ? :rolleyes:
Удалите тогда тему, пожалуйста!
пусть висит, всё равно в эмуляторах потеряется и не особо связана, так как это не эмуляторы
 
без сравнений, сами по себе, neve distressor la2a spaceecho понравились. OB синт не очень- ничего особенного. Бесплатный Obxf закрывает с OB вопросы для бесплатного.
 
  • Like
Реакции: GBR
Как Вам такое - плагин для поиска беслатных плагинов прям на канале Вашей DAW?))
Несколько лет назад рынок плагинов уже был перенасыщен. У меня в работе по 1 плагину за несколько лет добавляется, потому что все задачи уже давно покрыты и чего-то нового и полезного найти всё сложнее. Да и нет потребности.

К ИИ плагинам отношусь сильно скептически: если сам разраб не понимает в программировании и на 100% вайбкодер, то есть большая вероятность плохой поддержки в будущем. Как минимум, не стал бы ставить ранние версии, пока всё не протестируют хорошенько.
 
  • Like
Реакции: temaniak и riffcreator
повтор, уже и обсудили и потестировали )
Сейчас много повтора будет, ибо кануло в лето. С другой стороны не все успели прочитать - пусть будет.
Я в шоке, сколько сейчас будет нового софта на рынке!!!
Можно будет уже не писать ничего - всё сделают за нас. Главное скачать вовремя пока не прикрыли.
 
Сейчас много повтора будет, ибо кануло в лето. С другой стороны не все успели прочитать - пусть будет.
Это да. Я писал до падения сервера. Там у него кстати за это время ещё и нейро 808 появился
 
  • Like
Реакции: yunusmus
Протестировал. Результаты в архиве.
Плагины, эмулирующие разные типы компрессии не имеют ничего общего с тем, что эмулируют. Оба протестированных компрессора имеют один и тот же характер (стреляющие атаки), что указывает на один и тот же алгоритм у оптического и fet компрессора. Алгоритм обычного, цифорового компрессора, который пропускает атаки. Дополнительно, у этих плагинов не обнаружено действия авто релиза. Пружинный ревер заметно отличается от импульса пружины реального re201.
Вердикт: это просто какая то цифровая компрессия, по какому то безымянному алгоритму. Тот, кто называет это именами, ассоциирующимися с классикой, просто обманывает пользователей. Да, это наша новая реальность: теперь такой слоп в красивой обёртке могут создавать легко и в больших количествах.
 
Плагины, эмулирующие разные типы компрессии не имеют ничего общего с тем, что эмулируют.
Знакомая тема. Мне так ИИ много чего кодил. А когда свой алгоритм показал, он его исправил в сторону чего-то усредненого. В общем революция откладывается.
 
  • Salut
  • beer
Реакции: Kokarev Maxim и Alex_HS
я думаю ии плагины это будушее, они будут более креативными универсальными, и быстрее давать результат - платить за это все будем стабильностью.
И со временем каждый будет брать уже готовый плагин и переделывать под себя, или доделывать
 


Jonathan Knightsnare обновил свой офигенный нейрослоп-набор:

KNS16 — AMS RMX16 Inspired Reverb

Knightverb 2000 — Lexicon Model 200 Inspired Reverb

ps. Knightverb 2000 ОЧЕНЬ Old Lexi по звуку, я не верю что это просто "inspired", тут явно ноги от исходного eprom идут.
 
Последнее редактирование:
  • Like
Реакции: deplexer
а в чём это выражается?
Мне понравилось, но KNS16 больше зашёл, там такой читаемый вайб 80-х )
Это отдельная тема, но кратко Лексы старые все это такой гулкий "boomy halls/rooms", с сильно выраженными ранними отражениями , очень живой, окрашеный и непрозрачный звук, живущий отдельно от источника, но расширяющий его. TC например - скорее наоборот, прозрачный, добавляет ауру, клеется к звуку, синематический характер. Так вот тут - очень типичный лексикон.
 
  • я записываю
Реакции: deplexer


Jonathan Knightsnare обновил свой офигенный нейрослоп-набор:

KNS16 — AMS RMX16 Inspired Reverb

Knightverb 2000 — Lexicon Model 200 Inspired Reverb

ps. Knightverb 2000 ОЧЕНЬ Old Lexi по звуку, я не верю что это просто "inspired", тут явно ноги от исходного eprom идут.

Ой-ой-ой... так-так-так... :)
 
Плагины, эмулирующие разные типы компрессии не имеют ничего общего с тем, что эмулируют.
Как эти два утверждения существуют в одной теме? Типа:

- Сжечь ведьму.

- Но она красивая.

- Ладно... Но потом сжечь.



Эх мужчины...
 
Как эти два утверждения существуют в одной теме? Типа:

- Сжечь ведьму.

- Но она красивая.

- Ладно... Но потом сжечь.



Эх мужчины...
Они реально выглядят как вайбкод махровый, но субъективно компрессоры например очень зашли ЛИЧНО МНЕ. У меня не было именно компрессора alesis, но если плагин сразу звучит как я ожидаю - мне абсолютно все равно насколько он похож на то чего формально изображает. Субъективно лично мне очень напоминает DBX 166xl, вот прямо тоже самое делаешь и тоже самое получаешь.
 
Они реально выглядят как вайбкод махровый, но субъективно компрессоры например очень зашли ЛИЧНО МНЕ. У меня не было именно компрессора alesis, но если плагин сразу звучит как я ожидаю - мне абсолютно все равно насколько он похож на то чего формально изображает. Субъективно лично мне очень напоминает DBX 166xl, вот прямо тоже самое делаешь и тоже самое получаешь.
Выглядят они как раз нормально. А вот работают так, как сказал @KokarevMaxim, храни его и его свободное время всевышний.
В музыке упор должен быть на музыку вроде, остальное тлен и ненужная с(?)уета.

@Kokarev Maxim, На мой взгляд тот же 1176 от тукана в самой гениальной нашей дав выглядит как база. Кстати твоё бы мнение было интересно по ним. La2a он вроде прям по железке там на стримах делал.
 
Последнее редактирование:


Jonathan Knightsnare обновил свой офигенный нейрослоп-набор:

KNS16 — AMS RMX16 Inspired Reverb

Knightverb 2000 — Lexicon Model 200 Inspired Reverb

ps. Knightverb 2000 ОЧЕНЬ Old Lexi по звуку, я не верю что это просто "inspired", тут явно ноги от исходного eprom идут.

Мама рОдная, держите меня семеро!!! Божественный подгон! :Dle63::Dle63::Dle63:
 
  • Like
Реакции: yunusmus




SSL bus compressor похоже добавили (нет описания) и Дистрессор:

New: RF-DISS , an all-round compressor with eight ratios from 1:1 to an all-out MAX, an opto mode, two distortion modes and Auto Gain. It comes as its own download and installs beside Relic without touching your other Relic plugins.
 
Последнее редактирование:
  • Like
Реакции: yunusmus

Что то должно быть похожее на TR909 но в итоге вышло совсем другое, этакий гибрид 808 и 909! Несколько необычно звучит но очень и очень даже!
 
В общем революция откладывается.

Ну вот, вчера было время поразвлекаться. Напряг джеминайку темой алгоритмов.
Раз базовые приёмы промптинга и мультиягентных споров для вас пройденный этап, поднимаемся на уровень выше — туда, где агент перестаёт быть «генератором текста» и становится частью математического или эволюционного конвейера:
    • Эволюционный поиск алгоритмов (паттерн FunSearch / AlphaEvolve). Языковая модель плоха в линейном изобретении гениальных вещей, но гениальна как оператор мутации. Вместо того чтобы просить агента «придумай хитрый алгоритм», вы просите его написать простейшую базовую функцию и скрипт-оценщик (скорость, точность, потребление памяти). Дальше запускается цикл без вашего участия: скрипт скармливает агенту 2–3 лучшие версии кода из предыдущих поколений с требованием «скрести их или мутируй логику, чтобы побить рекорд», прогоняет результат через бенчмарк, отбрасывает слабых и оставляет победителей. Через 50–100 итераций рождаются странные, нечеловеческие эвристики, до которых модель за один проход не додумалась бы никогда.
    • Связка «Агент + SMT-солвер (Z3)» как машина для поиска трюков. Когда агент пытается схитрить (написать битовую магию, алгоритм без блокировок или хитрый парсер), он почти всегда ошибается на редких краевых случаях. Вместо тестов на примерах заставьте агента использовать библиотеку Z3 (математический доказатель теорем от Microsoft, ставится одной командой в Python). Схема такая: агент пишет «тупой, но 100% верный» эталон, затем пишет «хитрый и быстрый» алгоритм, а Z3 математически проверяет их эквивалентность на всех возможных входах сразу. Если трюк дырявый, Z3 не просто скажет «ошибка», а выдаст агенту конкретный контрпример (x = -2147483648), на котором логика ломается. Агент чинит, и так до строгого математического доказательства.
    • Отказ от написания алгоритмов в пользу солверов (OR-Tools / MiniZinc). Самый мощный способ решить сложную алгоритмическую задачу (расписание, маршрутизация, упаковка, распределение ресурсов, подбор комбинаций) — запретить агенту писать сам алгоритм. Вместо циклов и эвристик вы просите агента перевести вашу задачу на язык математических ограничений (Constraint Programming) для промышленного движка вроде Google OR-Tools. Агент за две минуты описывает правила игры в виде формул, а дальше написанный на C++ солвер находит математически идеальное решение за миллисекунды.
    • Синтез через «тупой оракул» (Superoptimization). Если нужно выжать максимум скорости из критического куска кода, не просите агента «оптимизировать». Попросите его сначала написать максимально примитивный перебор в лоб (оракул), а затем — сгенерировать скрипт, который перебирает или комбинирует примитивные операции (сдвиги, таблицы подстановок, SIMD), сверяя каждый вариант с оракулом. Так находят решения без единого ветвления (if), которые работают в десятки раз быстрее классического кода.
    • Принудительный кросс-доменный перенос (Physics-First Mapping). В весах нейросети знания сгруппированы по областям: на запрос «как отсортировать/сбалансировать/найти путь» она достаёт стандартные паттерны из Computer Science. Но если запретить ей термины программирования и заставить сначала смоделировать вашу задачу как физическую систему (например, «представь, что данные — это заряженные частицы в вязкой жидкости» или «как бы эту задачу решала грибница или система сообщающихся сосудов»), агент подтягивает математический аппарат из термодинамики, оптики или биологии — и только потом переводит его в код.
  • Если предыдущий уровень был про проверку и эволюцию кода, то следующий шаг — это смена самой природы вычислений. Самые гениальные алгоритмы в истории (вроде знаменитого быстрого обратного квадратного корня из Quake III или оптимизаторов современных компиляторов) выглядят не как «умный код с циклами», а как одна строчка математики или трюк с упаковкой данных.
    Вот пять приёмов, через которые можно заставить агента находить именно такие «инопланетные» решения:
    • Символьная регрессия (PySR) — замена алгоритма одной формулой. Иногда идеальный алгоритм — это вообще не код с ветвлениями, а компактное аналитическое уравнение, работающее за $O(1)$. Схема для агента: вы просите его прогнать вашу медленную или громоздкую логику на тысяче входов, сохранить таблицу «вход → выход» и скормить её библиотеке PySR (движок символьной регрессии на базе генетического программирования). Вместо подбора весов, как в нейросетях, PySR перебирает математические операторы и находит точную компактную формулу, которая воспроизводит поведение вашей системы. Агент просто заменяет сто строк кода одной строчкой алгебры.
    • Синтез с «дырками» (Program Sketching). Языковые модели отлично придумывают общую структуру алгоритма, но отвратительно считают в уме и почти никогда не угадывают «магические числа» (вроде констант в хэш-функциях или битовых сдвигов). Разделите труд: заставьте агента написать каркас алгоритма с дырками (??) на месте констант, порогов и битовых масок, а рядом — крошечный скрипт на Python или Z3, который сам подберёт точные значения под ваши тесты. Именно так рождается битовая магия, до которой человек додумывается годами.
    • E-графы и насыщение равенствами (egg / egglog). Когда агент оптимизирует алгоритм шаг за шагом, применение одного хорошего приёма часто закрывает дорогу к другому, ещё более выгодному (проблема порядка оптимизаций). E-граф — это структура данных из современных компиляторов, которая позволяет применить все возможные алгебраические и логические преобразования одновременно, упаковав миллионы эквивалентных версий вашего алгоритма в один компактный граф, а затем мгновенно извлечь оттуда вариант с минимальной ценой (меньше всего тактов процессора или обращений к памяти). Агенты отлично умеют переводить логику в правила для egglog.
    • Эволюция с сохранением «странных» ниш (MAP-Elites). У обычного эволюционного поиска (вроде FunSearch) есть слабое место: он быстро скатывается в локальный оптимум, потому что одна удачная версия убивает все «странные» мутации раньше, чем те успеют раскрыться. Алгоритм MAP-Elites строит таблицу характеристик (например, по одной оси — расход памяти, по другой — количество ветвлений if) и хранит лучшего чемпиона в каждой клетке. Агент скрещивает чемпиона из клетки «ноль памяти, но медленно» с чемпионом из клетки «много памяти, но за один такт» — и на стыке рождаются прорывные гибриды, которые жадный отбор уничтожил бы на втором шаге.
    • Битборды и инверсия представления (Data-Oriented Design). Самый чистый способ победить любой сложный алгоритм — изменить форму хранения данных так, чтобы задача решалась сама собой. Классический пример: шахматные движки не хранят доску как массив 8×8, они упаковывают фигуры в 64-битные целые числа (битборды), после чего поиск всех возможных ходов превращается в три побитовые операции AND и SHIFT за один такт процессора. Запретите агенту писать логику поверх текущих структур и дайте команду: «Переупакуй данные в плоские массивы (Structure of Arrays) или битовые маски так, чтобы задача решалась линейным проходом по кэшу L1 без единого ветвления».
  • В проектах, которые вы сейчас собираете, узкое место чаще упирается в скорость вычислений и память или в сложность самой логики и правил?
На базе этого создал скилл

и для теста создал jsfx. На всё около часа.

1795020239732.png



пример звука


 
скилл и код ниже
---
name: algorithmic-synthesis
description: >-
Discover, synthesize, and formally verify non-trivial, high-performance
algorithms instead of writing standard imperative heuristics. Use when asked
to find an optimal or branchless algorithm, eliminate computational or cache
bottlenecks, pack data into bitboards/SoA, solve combinatorial/scheduling/routing
problems (OR-Tools, MiniZinc), simplify expressions without phase-ordering
traps (egglog), discover formulas/constants (PySR, program sketching,
superoptimization), run automated evolutionary code search (FunSearch,
AlphaEvolve, MAP-Elites), break out of standard CS priors (physics-first
mapping), or prove equivalence/correctness with SMT (Z3).
---

# Algorithmic Synthesis

A structured methodology for discovering mathematically optimal, hardware-sympathetic, and formally verified algorithms instead of defaulting to textbook loops, nested conditionals, or brittle hand-tuned heuristics.

## Strategy Selection Matrix

Pick the primary strategy—or chain them as a pipeline (typically **Oracle → Synthesis/Evolution → Formal Proof → Benchmark**):

| Problem / Bottleneck | Primary Approach | Tooling / Pattern |
| :--- | :--- | :--- |
| Scheduling, routing, packing, resource allocation, combination selection | Forbid imperative search loops; model declaratively | `ortools` (`CP-SAT`, `routing`), `MiniZinc` |
| Cache misses, AoS pointer chasing, multi-flag state checks | Repack layout before touching control flow | Flat SoA arrays, 64-bit bitboards (`L1` linear pass) |
| Stuck in textbook CS framing; need novel heuristic | Ban CS jargon in step 1; model as physical/bio system | Physics-First Mapping → discretize |
| Bulky scoring trees / multi-line formulas replaceable by $O(1)$ math | Sample input→output table and extract equation | `PySR` symbolic regression + oracle error check |
| Algebraic / bitwise expression simplification with phase-ordering traps | Explore all equivalent rewrites simultaneously | E-graphs (`egg` / `egglog`) + hardware cost model |
| Tiny hot kernel needing magic constants, masks, or branchless code | Write skeleton with `??` holes or enumerate primitives | Program Sketching / Superopt (shifts, LUTs, SIMD) |
| Bit magic, lock-free transitions, tricky parsers, edge-case bugs | Prove equivalence against dumb oracle for all inputs | `z3-solver` (`BitVec` / bounded checks) |
| Open-ended heuristic optimization with measurable fitness | Run unattended multi-generation mutation loop | `FunSearch` / `AlphaEvolve` (50–100+ gens) |
| Greedy evolution gets trapped in local optima | Preserve champions across tradeoff niches & crossbreed | `MAP-Elites` 2D behavioral grid |

---

## 1. Paradigm & Representation Shifts

Before writing imperative logic, verify whether the algorithm itself can be eliminated by changing the model or data layout:

* **Constraint Solvers over Heuristics (`OR-Tools` / `MiniZinc`):** For scheduling, routing, packing, resource allocation, or combinatorial search, **do not write custom backtracking, greedy loops, or ad-hoc heuristics**. Formulate variables, domains, and mathematical constraints and delegate execution to an industrial solver (`ortools.sat.python.cp_model` for integer/Boolean/scheduling constraints, `ortools.constraint_solver.routing` for VRP/TSP, or `MiniZinc`).
* **Data-Oriented Redesign & Bitboards:** **Refuse to optimize logic on top of poor data structures first.** Reshape Arrays of Structures (AoS) into flat Structure of Arrays (SoA), or pack state into 64-bit integer bitboards so multi-step rules collapse into branchless bitwise ops (`AND`, `OR`, `XOR`, `SHIFT`) executed as a linear pass over L1 cache without a single branch.
* **Symbolic Regression (`PySR`):** To replace bloated scoring pipelines or threshold trees with an $O(1)$ closed-form algebraic expression, run the slow reference implementation across a representative grid of inputs, export the `(input -> output)` table, and run `PySR` to discover compact equations. Validate max approximation error and discrete boundary rounding against the reference oracle.
* **Cross-Domain Physical Mapping (Physics-First):** Neural priors collapse to standard CS patterns when prompted with CS vocabulary. **Explicitly forbid programming terms during step 1** (do not wait until CS heuristics fail if novelty is needed). Model the problem purely as a physical, optical, thermodynamic, or biological system (charged particles in viscous fluid, communicating vessels, potential fields, *Physarum*/slime mold, spring-mass relaxation) to import continuous math tools, and only then discretize into code.

---

## 2. Algebraic, Oracle-Backed Synthesis & Formal Verification

Never trust clever bit-twiddling, parsers, lock-free tricks, or discovered constants on sample unit tests alone:

* **Reference Oracle First:** Always implement a slow, primitive, undeniably correct brute-force or textbook oracle as ground truth before synthesizing anything clever.
* **Equality Saturation with E-Graphs (`egg` / `egglog`):** To avoid phase-ordering traps during algebraic or logical optimization, encode equivalence rewrite rules into an E-graph (`egglog` in Python / `egg` in Rust). Apply all rewrites simultaneously and extract the expression minimizing an explicit **hardware cost model** (CPU cycle latency, memory loads, branch count).
* **Program Sketching (`??` Holes):** Models design overall structure well but fail at mental magic-constant math. Write the algorithmic skeleton with explicit unknown holes (`??`) for hash multipliers, shift widths, masks, and thresholds. Use a solver or search script (ideally CEGIS-backed by Z3 rather than a tiny test suite) to synthesize exact values.
* **Superoptimization via Brute-Force Oracle:** For tiny, ultra-hot kernels, write a search script that enumerates and composes primitive operations (**shifts, masks, lookup tables / LUTs, SWAR, SIMD**) to discover branchless (`no if`) sequences. Filter candidates cheaply on random + boundary tests first, then formally verify survivors against the oracle.
* **SMT Equivalence Proofs & Counterexample Loop (`Z3`):** Translate both the reference oracle and the optimized candidate into `z3-solver` constraints and query equivalence over the **entire input domain**:
* **Machine-word fidelity:** Always model fixed-width integers and bit-twiddling with `z3.BitVec(name, 32/64)` (never unbounded `z3.Int`), paying attention to signed vs. logical right shifts (`>>` vs. `z3.LShR`) and wrapping overflow.
* **Stateful / Concurrent / Parser code:** For lock-free protocols or tricky parsers, encode bounded state transitions / `k`-step unrolling and interleavings to check invariants and crash-freedom.
* **Counterexample loop:** Whenever Z3 returns `sat`, feed its concrete counterexample (e.g., `x = -2147483648`) back into the candidate design and iterate until Z3 proves `unsat` (zero counterexamples).

---

## 3. Automated Evolutionary Discovery

When no closed-form math or exact solver formulation fits, operate as a mutation/crossover operator inside an automated search harness rather than guessing once in chat:

* **Unattended `FunSearch` / `AlphaEvolve` Loop:** Build a self-contained driver script with a deterministic correctness gate (against the oracle) and performance scorer (latency, allocations, objective quality). Maintain an archive of scored implementations and run an **automated multi-generation loop (target 50–100+ iterations)** where each step samples the **top 2–3 champions** from the archive, mutates or crosses over their logic, discards failing/slower candidates, and promotes record-breakers.
* **Quality-Diversity Search (`MAP-Elites`):** Standard greedy evolution collapses early into local optima. Maintain a 2D behavioral descriptor grid (e.g., memory footprint vs. branch count, or LUT size vs. instruction count) storing the single best champion per cell. Periodically crossbreed distant niche champions (such as a zero-memory slow variant with a lookup-heavy single-cycle variant) to synthesize breakthrough hybrids.

---

## Execution Rules

1. **Benchmark on realistic, unpredictable data:** Measure candidate speed against the baseline after warmup and prevent compiler dead-code elimination. For branchless code, **benchmark on random/unpredictable branch inputs**—sorted or uniform test inputs allow the CPU branch predictor to hit ~100% accuracy and mask branching penalties.
2. **Retain the oracle permanently:** Keep the simple brute-force reference in the test suite so future optimizations and mutations remain anchored to exact behavior.
3. **Explain the invariant:** Briefly document the mathematical, bitwise, physical, or solver invariant making the synthesized algorithm valid.

---

## Gotchas

* **Premature micro-optimization:** Do not apply bitboards, superoptimization, or `egglog` before profiling or complexity analysis confirms the hot spot.
* **Unverified bit-width & FP traps:** Signed overflow, `INT_MIN` negation, shift-by-width UB, and floating-point `NaN`/subnormals silently break bit hacks unless modeled accurately with `z3.BitVec` / `z3.FP` or exhaustive boundary checks.
* **Solver modeling bugs (both directions):** An *under-constrained* `OR-Tools`/`Z3` model produces fast nonsense; an *over-constrained* model returns `INFEASIBLE` silently. Always pair solver outputs with an independent forward invariant validator.
* **Sketching & `PySR` overfitting:** Constants solved only against small unit-test sets overfit unseen inputs—verify sketches over the full domain with Z3. Remember `PySR` outputs floating-point approximations (and requires a Julia runtime), so guard discrete or integer boundaries explicitly.


В качестве эксперимента с этим скиллом создали jsfx с одного промпта.
desc:Attack Eater & Bow Synth (Adaptive Guitar Transient Remover)
//tags: guitar dynamics swell transient synth
//author: Synthesized via Algorithmic Synthesis (C99 -> EEL2)

slider1:65<10,250,1>Attack Swell Time (ms)
slider2:100<0,100,1>Speed Adapt (%)
slider3:100<10,200,1>Eat Depth (%)
slider4:0<-12,12,0.5>Sensitivity / Pickups (dB)
slider5:1015<350,3000,10>Pick Crossover (Hz)
slider6:4.5<1.5,15,0.5>Shred Body Floor (ms)
slider7:100<0,100,1>Attack Eater Mix (%)
slider8:0<0,100,1>Synth Layer Mix (%)
slider9:1<0,2,1{Warm Bow Pad,Analog Poly Brass,Octave Shimmer Organ}>Synth Mode
slider10:55<0,100,1>Synth Tone / VCF (%)
slider11:65<0,100,1>Synth Stereo Chorus (%)
slider12:0<-18,18,0.5>Output Gain (dB)

in_pin:left input
in_pin:right input
out_pin:left output
out_pin:right output

@Init
ext_noinit = 0;

// Non-overlapping memory layout
MEM_BLK_BODY = 0; // [0..3] 4-block sliding max for body env
MEM_DLY_L = 64; // [64..4159] 4096-sample chorus delay L
MEM_DLY_R = 4200; // [4200..8295] 4096-sample chorus delay R
DLY_MASK = 4095;

GFX_LEN = 256;
GFX_IN = 8400; // [8400..8655]
GFX_OUT = 8700; // [8700..8955]
GFX_GB = 9000; // [9000..9255]
GFX_GH = 9300; // [9300..9555]
GFX_D = 9600; // [9600..9855]

memset(0, 0, 10000);

DENORM_FLOOR = pow(10.0, -20.0);

function clamp(v, lo, hi) (
min(max(v, lo), hi);
);

function sanitize(x) (
(x != x || abs(x) > 32.0) ? 0.0 : x;
);

function flush_denorm(v) (
(abs(v) < DENORM_FLOOR) ? 0.0 : v;
);

function ms_to_pole(ms, inv_fs) local(tau_s) (
tau_s = max(ms, 0.02) * 0.001;
exp(-inv_fs / tau_s);
);

function ms_to_pole_fast(ms, inv_fs) local(x) (
x = inv_fs / (max(ms, 0.5) * 0.001);
(x < 0.05) ?
(1.0 - x * (1.0 - x * (0.5 - x * (0.16666667 - 0.04166667 * x)))) :
exp(-x);
);

function asym_onepole(prev, target, a_rise, a_fall) local(a) (
a = (target > prev) ? a_rise : a_fall;
max(a * prev + (1.0 - a) * target, DENORM_FLOOR);
);

function fast_tanh(x) local(xc, x2) (
xc = clamp(x, -3.0, 3.0);
x2 = xc * xc;
xc * (27.0 + x2) / (27.0 + 9.0 * x2);
);

function compute_band_gain(ef, es, eps, d0, k_knee, g_depth, min_g) local(delta, u, phi, g) (
delta = log((ef + eps) / (es + eps));
u = max(0.0, delta - d0);
phi = (u * u) / (u + k_knee + 0.000000000001);
g = exp(-g_depth * phi);
clamp(g, min_g, 1.0);
);

// Cytomic Trapezoidal (TPT) SVF: unconditionally stable under fast envelope modulation
function svf_lp(x, g_svf, k_svf) instance(ic1, ic2) local(a1, a2, a3, v1, v2, v3) (
a1 = 1.0 / (1.0 + g_svf * (g_svf + k_svf));
a2 = g_svf * a1;
a3 = g_svf * a2;
v3 = x - ic2;
v1 = a1 * ic1 + a2 * v3;
v2 = ic2 + a2 * ic1 + a3 * v3;
ic1 = 2.0 * v1 - ic1;
ic2 = 2.0 * v2 - ic2;
v2;
);

function read_delay_lerp(buf_base, w_idx, dly_spl) local(rpos, i0, i1, frac) (
rpos = w_idx - dly_spl;
rpos < 0 ? rpos += 4096;
i0 = floor(rpos) & DLY_MASK;
i1 = (i0 + 1) & DLY_MASK;
frac = rpos - floor(rpos);
buf_base[i0] + frac * (buf_base[i1] - buf_base[i0]);
);

function recalc_params() (
inv_fs = 1.0 / max(srate, 8000.0);

swell_ms = clamp(slider1, 10.0, 250.0);
speed_adapt = clamp(slider2 * 0.01, 0.0, 1.0);
depth_val = 1.08 * clamp(slider3 * 0.01, 0.1, 2.0);
sens_db = clamp(slider4, -12.0, 12.0);
xo_hz = clamp(slider5, 350.0, min(3000.0, 0.4 * srate));
fast_body_ms = clamp(slider6, 1.5, min(15.0, swell_ms));
fast_high_ms = clamp(max(18.5, fast_body_ms + 4.0), fast_body_ms, swell_ms);

ae_mix = clamp(slider7 * 0.01, 0.0, 1.0);
synth_mix = clamp(slider8 * 0.01, 0.0, 1.0);
synth_mode = floor(slider9 + 0.5);
synth_tone = clamp(slider10 * 0.01, 0.0, 1.0);
chorus_amt = clamp(slider11 * 0.01, 0.0, 1.0);
out_gain = exp(slider12 * 0.11512925465);

// Sensitivity shifts deadzone & noise floor smoothly for singles vs hot humbuckers
sens_nepers = sens_db * 0.11512925465;
delta0 = clamp(0.318 - 0.22 * sens_nepers, 0.06, 0.65);
knee = 0.11;
noise_eps = exp((-76.0 - 0.8 * sens_db) * 0.11512925465);
floor_min_g = exp(-48.0 * 0.11512925465);

block_len = max(1, floor(0.003 * srate + 0.5));
a_xo = exp(-2.0 * $pi * xo_hz * inv_fs);
a_body_down = ms_to_pole(4.0, inv_fs);
a_hi_down = ms_to_pole(5.0, inv_fs);
a_fall = ms_to_pole(3.1, inv_fs);
a_spd_fast_hi= ms_to_pole(6.0, inv_fs);
a_spd_ref = ms_to_pole(12.0, inv_fs);
a_d_up = ms_to_pole(31.5, inv_fs);
a_d_dn = ms_to_pole(494.0, inv_fs);
a_r_up = ms_to_pole(4.0, inv_fs);
a_r_dn = ms_to_pole(28.0, inv_fs);
a_g_down = ms_to_pole(0.025, inv_fs);
a_g_up = ms_to_pole(0.50, inv_fs);

d_deadzone = 0.127;
d_scale = 7.0;
log_rat_body = log(fast_body_ms / swell_ms);
log_rat_high = log(fast_high_ms / swell_ms);

// Synth layer constants
a_oct_dc = exp(-2.0 * $pi * 150.0 * inv_fs);
a_syn_dc = exp(-2.0 * $pi * 25.0 * inv_fs);
a_synth_env = ms_to_pole(18.0, inv_fs);
lfo_inc1 = 2.0 * $pi * 0.43 * inv_fs;
lfo_inc2 = 2.0 * $pi * 1.17 * inv_fs;
gfx_step = max(1, floor(srate / 120.0));
);

// State initialization
blk_cur_max = 0.0;
blk_cnt = 0;
ef_body = DENORM_FLOOR;
ef_high = DENORM_FLOOR;
e_spd_ref_tot = DENORM_FLOOR;
e_spd_fast_hi = DENORM_FLOOR;
e_spd_ref_hi = DENORM_FLOOR;
refractory = 0.0;
density = DENORM_FLOOR;
d_eff = 0.0;

lpL = 0.0;
lpR = 0.0;
ref_body_s1 = DENORM_FLOOR;
ref_body_s2 = DENORM_FLOOR;
ref_high_s1 = DENORM_FLOOR;
ref_high_s2 = DENORM_FLOOR;
g_body_smooth = 1.0;
g_high_smooth = 1.0;

// Synth state
oct_dc_L = 0.0;
oct_dc_R = 0.0;
syn_dc_L = 0.0;
syn_dc_R = 0.0;
synth_env_s = DENORM_FLOOR;
vcf_cut_disp = 1000.0;
dly_w = 0;
lfo_ph1 = 0.0;
lfo_ph2 = 0.0;

// GFX telemetry state
gfx_cnt = 0;
gfx_wpos = 0;
gfx_pk_in = 0.0;
gfx_pk_out = 0.0;
tau_body_disp = 65.0;

recalc_params();

@slider
recalc_params();

@Sample
inL = sanitize(spl0);
inR = sanitize(spl1);

// 1. Complementary zero-phase-sum crossover per channel
x_low_L = flush_denorm(a_xo * lpL + (1.0 - a_xo) * inL);
lpL = x_low_L;
x_high_L = inL - x_low_L;

x_low_R = flush_denorm(a_xo * lpR + (1.0 - a_xo) * inR);
lpR = x_low_R;
x_high_R = inR - x_low_R;

// 2. Stereo-linked detection preserves stereo image
abs_lo = max(abs(x_low_L), abs(x_low_R));
abs_hi = max(abs(x_high_L), abs(x_high_R));

// 12ms 4-block sliding peak on body (no 82Hz ripple, 0ms onset lag)
blk_cur_max = max(blk_cur_max, abs_lo);
raw_max = max(blk_cur_max, max(max(MEM_BLK_BODY[0], MEM_BLK_BODY[1]), max(MEM_BLK_BODY[2], MEM_BLK_BODY[3])));
ef_body = max(max(raw_max, a_body_down * ef_body), DENORM_FLOOR);

blk_cnt += 1;
blk_cnt >= block_len ? (
MEM_BLK_BODY[3] = MEM_BLK_BODY[2];
MEM_BLK_BODY[2] = MEM_BLK_BODY[1];
MEM_BLK_BODY[1] = MEM_BLK_BODY[0];
MEM_BLK_BODY[0] = blk_cur_max;
blk_cur_max = 0.0;
blk_cnt = 0;
);

ef_high = max(max(abs_hi, a_hi_down * ef_high), DENORM_FLOOR);

// 3. Refractory playing-speed density reservoir D in [0, 1]
e_spd_fast_hi = max(max(abs_hi, a_spd_fast_hi * e_spd_fast_hi), DENORM_FLOOR);
e_spd_ref_tot = asym_onepole(e_spd_ref_tot, ef_body, a_spd_ref, a_spd_ref);
e_spd_ref_hi = asym_onepole(e_spd_ref_hi, e_spd_fast_hi, a_spd_ref, a_spd_ref);

eps_hi_spd = max(noise_eps, 0.12 * ef_body);
eps_hi_gain = max(noise_eps, 0.04 * ef_body);

d_tot = log((ef_body + noise_eps) / (e_spd_ref_tot + noise_eps));
d_hi = log((e_spd_fast_hi + eps_hi_spd) / (e_spd_ref_hi + eps_hi_spd));
u_spd = max(0.0, max(d_tot, d_hi) - delta0);

raw_onset = clamp(u_spd * 2.85, 0.0, 1.0);
spike = raw_onset * (1.0 - refractory);
refractory = asym_onepole(refractory, raw_onset, a_r_up, a_r_dn);

density = asym_onepole(density, spike, a_d_up, a_d_dn);
d_norm = clamp((density - d_deadzone) * d_scale, 0.0, 1.0);
d_eff = speed_adapt * (d_norm * d_norm * (3.0 - 2.0 * d_norm));

// 4. Speed-adaptive 2-pole asymmetric swell envelopes
tau_body_eff = swell_ms * exp(log_rat_body * d_eff);
tau_high_eff = swell_ms * exp(log_rat_high * d_eff);
tau_body_disp = tau_body_eff;

a_rise_body = ms_to_pole_fast(tau_body_eff * 0.465, inv_fs);
a_rise_high = ms_to_pole_fast(tau_high_eff * 0.465, inv_fs);

ref_body_s1 = asym_onepole(ref_body_s1, ef_body, a_rise_body, a_fall);
ref_body_s2 = asym_onepole(ref_body_s2, ref_body_s1, a_rise_body, a_fall);
ref_high_s1 = asym_onepole(ref_high_s1, ef_high, a_rise_high, a_fall);
ref_high_s2 = asym_onepole(ref_high_s2, ref_high_s1, a_rise_high, a_fall);

depth_body = depth_val * (1.0 - 0.35 * d_eff);
min_gain_body = floor_min_g + (0.28 - floor_min_g) * (d_eff * d_eff);

g_body_raw = compute_band_gain(ef_body, ref_body_s2, noise_eps, delta0, knee, depth_body, min_gain_body);
g_high_raw = compute_band_gain(ef_high, ref_high_s2, eps_hi_gain, delta0, knee, depth_val, floor_min_g);

g_body_smooth = asym_onepole(g_body_smooth, g_body_raw, a_g_up, a_g_down);
g_high_smooth = asym_onepole(g_high_smooth, g_high_raw, a_g_up, a_g_down);

ae_L = g_body_smooth * x_low_L + g_high_smooth * x_high_L;
ae_R = g_body_smooth * x_low_R + g_high_smooth * x_high_R;

clean_L = inL + ae_mix * (ae_L - inL);
clean_R = inR + ae_mix * (ae_R - inR);

// 5. Layer 2: Polyphonic Bow-Synth / Pad Shaper (runs only when Synth Layer Mix > 0)
outL = clean_L;
outR = clean_R;

synth_mix > 0.001 ? (
env_tot = max(ef_body, ef_high);
synth_env_s = a_synth_env * synth_env_s + (1.0 - a_synth_env) * env_tot;

// Envelope-normalized polyphonic waveshaper (keeps harmonic character steady into decay)
norm_s = 1.0 / (synth_env_s + 0.020);
xnL = ae_L * norm_s;
xnR = ae_R * norm_s;

// Gate near noise floor so hum never amplifies during silence
gate_s = synth_env_s / (synth_env_s + noise_eps * 16.0);
amp_s = 0.85 * pow(max(synth_env_s, DENORM_FLOOR), 0.78) * gate_s;

synth_mode == 0 ? (
// Warm Bow Pad: smooth odd/even harmonic warmth
exL = fast_tanh(2.1 * xnL + 0.25 * (xnL * xnL));
exR = fast_tanh(2.1 * xnR + 0.25 * (xnR * xnR));
f_min = 240.0 + 300.0 * synth_tone;
f_max = 1400.0 + 2800.0 * synth_tone;
res_s = 0.22 + 0.25 * synth_tone;
) : synth_mode == 1 ? (
// Analog Poly Brass: asymmetric PWM-style waveshaping + resonant filter sweep
exL = fast_tanh(3.4 * xnL + 0.65 * (xnL * xnL - 0.25));
exR = fast_tanh(3.4 * xnR + 0.65 * (xnR * xnR - 0.25));
f_min = 200.0 + 250.0 * synth_tone;
f_max = 2200.0 + 4600.0 * synth_tone;
res_s = 0.45 + 0.30 * synth_tone;
) : (
// Octave Shimmer Organ: fundamental + DC-blocked frequency doubler (+1 oct)
octL_raw = xnL * xnL;
octR_raw = xnR * xnR;
oct_dc_L = a_oct_dc * oct_dc_L + (1.0 - a_oct_dc) * octL_raw;
oct_dc_R = a_oct_dc * oct_dc_R + (1.0 - a_oct_dc) * octR_raw;
octL = octL_raw - oct_dc_L;
octR = octR_raw - oct_dc_R;
exL = 0.65 * fast_tanh(2.0 * xnL) + (0.65 + 0.55 * synth_tone) * fast_tanh(2.4 * octL);
exR = 0.65 * fast_tanh(2.0 * xnR) + (0.65 + 0.55 * synth_tone) * fast_tanh(2.4 * octR);
f_min = 380.0 + 350.0 * synth_tone;
f_max = 2600.0 + 5200.0 * synth_tone;
res_s = 0.28 + 0.25 * synth_tone;
);

// VCF cutoff tracks the attack-eater S-curve!
vcf_mod = clamp(g_body_smooth * clamp(synth_env_s * 5.0, 0.0, 1.0), 0.0, 1.0);
vcf_hz = min(f_min * exp(log(f_max / f_min) * vcf_mod), 0.42 * srate);
vcf_cut_disp = vcf_hz;

g_svf = tan($pi * vcf_hz * inv_fs);
k_svf = 2.0 - 2.0 * res_s;

synL = svfL.svf_lp(exL * amp_s, g_svf, k_svf);
synR = svfR.svf_lp(exR * amp_s, g_svf, k_svf);

// 25 Hz DC blocker removes asymmetric-shaper offset before downstream amp sims
syn_dc_L = a_syn_dc * syn_dc_L + (1.0 - a_syn_dc) * synL;
syn_dc_R = a_syn_dc * syn_dc_R + (1.0 - a_syn_dc) * synR;
synL -= syn_dc_L;
synR -= syn_dc_R;

// Stereo quadrature ensemble chorus
chorus_amt > 0.001 ? (
lfo_ph1 += lfo_inc1;
lfo_ph1 > 2.0 * $pi ? lfo_ph1 -= 2.0 * $pi;
lfo_ph2 += lfo_inc2;
lfo_ph2 > 2.0 * $pi ? lfo_ph2 -= 2.0 * $pi;

modL = 0.7 * sin(lfo_ph1) + 0.3 * sin(lfo_ph2);
modR = 0.7 * cos(lfo_ph1) - 0.3 * cos(lfo_ph2);

base_dly = 0.011 * srate;
depth_dly = 0.0038 * srate * chorus_amt;

dly_spl_L = clamp(base_dly + depth_dly * modL, 1.0, 4094.0);
dly_spl_R = clamp(base_dly + depth_dly * modR, 1.0, 4094.0);

MEM_DLY_L[dly_w] = synL;
MEM_DLY_R[dly_w] = synR;

chL = read_delay_lerp(MEM_DLY_L, dly_w, dly_spl_L);
chR = read_delay_lerp(MEM_DLY_R, dly_w, dly_spl_R);
dly_w = (dly_w + 1) & DLY_MASK;

synL = synL + chorus_amt * 0.65 * (chR - synL * 0.35);
synR = synR + chorus_amt * 0.65 * (chL - synR * 0.35);
);

outL = clean_L + synth_mix * (synL - clean_L);
outR = clean_R + synth_mix * (synR - clean_R);
);

spl0 = clamp(outL * out_gain, -4.0, 4.0);
spl1 = clamp(outR * out_gain, -4.0, 4.0);

// 6. Downsampled history for @GFX scope
gfx_pk_in = max(gfx_pk_in, max(abs(inL), abs(inR)));
gfx_pk_out = max(gfx_pk_out, max(abs(spl0), abs(spl1)));
gfx_cnt += 1;
gfx_cnt >= gfx_step ? (
GFX_IN[gfx_wpos] = min(1.0, gfx_pk_in);
GFX_OUT[gfx_wpos] = min(1.0, gfx_pk_out);
GFX_GB[gfx_wpos] = g_body_smooth;
GFX_GH[gfx_wpos] = g_high_smooth;
GFX_D[gfx_wpos] = d_eff;
gfx_wpos = (gfx_wpos + 1) & 255;
gfx_pk_in = 0.0;
gfx_pk_out = 0.0;
gfx_cnt = 0;
);

@GFX 640 300
// Background
gfx_set(0.07, 0.08, 0.11, 1.0);
gfx_rect(0, 0, gfx_w, gfx_h);

pad = 14;
top_h = 66;
scope_x = pad;
scope_y = top_h + 8;
scope_w = gfx_w - 2 * pad;
scope_h = gfx_h - scope_y - 28;

// Header & telemetry bars
gfx_set(0.11, 0.13, 0.18, 1.0);
gfx_rect(pad, 10, gfx_w - 2 * pad, top_h - 10);

// 3-column header meters without overlap
col_w = max(80, (gfx_w - 2 * pad - 44) / 3);
x1 = pad + 10;
x2 = x1 + col_w + 12;
x3 = x2 + col_w + 12;

// Col 1: Density D meter
gfx_set(0.75, 0.80, 0.88, 1.0);
gfx_x = x1; gfx_y = 16;
gfx_drawstr("D: ");
gfx_drawnumber(d_eff * 100.0, 0);
gfx_drawstr("% (");
gfx_drawnumber(tau_body_disp, 1);
gfx_drawstr("ms)");

gfx_set(0.18, 0.21, 0.27, 1.0);
gfx_rect(x1, 34, col_w, 12);
gfx_set(0.15 + 0.82 * d_eff, 0.78 - 0.35 * d_eff, 0.90 - 0.70 * d_eff, 1.0);
gfx_rect(x1, 34, col_w * d_eff, 12);

// Col 2: Body Gain meter
gfx_set(0.95, 0.78, 0.25, 1.0);
gfx_x = x2; gfx_y = 16;
gfx_drawstr("Body (<Cross)");
gfx_set(0.18, 0.21, 0.27, 1.0);
gfx_rect(x2, 34, col_w, 12);
gfx_set(0.95, 0.78, 0.25, 1.0);
gfx_rect(x2, 34, col_w * g_body_smooth, 12);

// Col 3: Pick Gain meter
gfx_set(0.95, 0.38, 0.75, 1.0);
gfx_x = x3; gfx_y = 16;
gfx_drawstr("Pick (>Cross)");
gfx_set(0.18, 0.21, 0.27, 1.0);
gfx_rect(x3, 34, col_w, 12);
gfx_set(0.95, 0.38, 0.75, 1.0);
gfx_rect(x3, 34, col_w * g_high_smooth, 12);

// Scope frame & grid
gfx_set(0.05, 0.06, 0.08, 1.0);
gfx_rect(scope_x, scope_y, scope_w, scope_h);
gfx_set(0.16, 0.19, 0.25, 1.0);
gfx_line(scope_x, scope_y, scope_x + scope_w, scope_y);
gfx_line(scope_x, scope_y + scope_h, scope_x + scope_w, scope_y + scope_h);
gfx_line(scope_x, scope_y, scope_x, scope_y + scope_h);
gfx_line(scope_x + scope_w, scope_y, scope_x + scope_w, scope_y + scope_h);
gfx_line(scope_x, scope_y + scope_h * 0.5, scope_x + scope_w, scope_y + scope_h * 0.5);

// Plot Input (gray fill), Output (cyan), Body Gain (gold), Pick Gain (magenta)
i = 0;
prev_x = scope_x;
prev_gb_y = scope_y + scope_h;
prev_gh_y = scope_y + scope_h;
prev_d_y = scope_y + scope_h;

loop(GFX_LEN,
idx = (gfx_wpos + i) & 255;
xx = scope_x + (i / (GFX_LEN - 1)) * scope_w;

v_in = GFX_IN[idx];
v_out = GFX_OUT[idx];
v_gb = GFX_GB[idx];
v_gh = GFX_GH[idx];
v_d = GFX_D[idx];

// Input envelope bars (subtle gray)
gfx_set(0.32, 0.36, 0.44, 0.55);
bar_h_in = v_in * (scope_h - 8);
gfx_line(xx, scope_y + scope_h - 2, xx, scope_y + scope_h - 2 - bar_h_in);

// Output envelope bars (bright cyan)
gfx_set(0.20, 0.85, 0.92, 0.80);
bar_h_out = v_out * (scope_h - 8);
gfx_line(xx, scope_y + scope_h - 2, xx, scope_y + scope_h - 2 - bar_h_out);

gb_y = scope_y + scope_h - 2 - v_gb * (scope_h - 8);
gh_y = scope_y + scope_h - 2 - v_gh * (scope_h - 8);
d_y = scope_y + scope_h - 2 - v_d * (scope_h - 8);

i > 0 ? (
gfx_set(0.95, 0.78, 0.25, 0.95);
gfx_line(prev_x, prev_gb_y, xx, gb_y);

gfx_set(0.95, 0.38, 0.75, 0.90);
gfx_line(prev_x, prev_gh_y, xx, gh_y);

gfx_set(1.0, 0.50, 0.15, 0.55);
gfx_line(prev_x, prev_d_y, xx, d_y);
);

prev_x = xx;
prev_gb_y = gb_y;
prev_gh_y = gh_y;
prev_d_y = d_y;
i += 1;
);

// Legend footer
gfx_x = scope_x; gfx_y = gfx_h - 20;
gfx_set(0.45, 0.50, 0.58, 1.0); gfx_drawstr("In(Gray) ");
gfx_set(0.20, 0.85, 0.92, 1.0); gfx_drawstr("Out(Cyan) ");
gfx_set(0.95, 0.78, 0.25, 1.0); gfx_drawstr("Body(Gold) ");
gfx_set(0.95, 0.38, 0.75, 1.0); gfx_drawstr("Pick(Pink) ");
gfx_set(1.00, 0.50, 0.15, 1.0); gfx_drawstr("D(Orange)");
synth_mix > 0.001 ? (
gfx_set(0.65, 0.95, 0.55, 1.0);
gfx_drawstr(" VCF:");
gfx_drawnumber(vcf_cut_disp, 0);
gfx_drawstr("Hz");
);
 
  • Like
Реакции: Mikeleon

Сейчас просматривают