Мы привыкли, что языки программирования создаются в недрах корпораций (Golang от Google, Swift от Apple) или академических лабораторий (Haskell, OCaml). Но что, если язык — это не продукт многолетнего планирования, а "вайб-кодинг"? Попытка решить одну конкретную боль, которая в процессе обрастает логикой и превращается в нечто большее?

Проект Sound (github.com/lapkin25/sound) начался именно так. Это не "убийца Python" и не очередной синтаксический сахар над C. Это эксперимент: можно ли построить систему, где побайтовая идентичность вычислений — это не удача, а часть контракта языка?

Сегодня мы разберем, как Sound прошел путь от "склеивания Python и Java" до полноценного исчисления, и почему его архитектура заставляет по-новому взглянуть на детерминизм.


1. Философия: "Я не верю вашим логам"

Главная проблема современного ПО — недетерминизм. Вы пишете a + b * c. На вашем ноутбуке (Intel) результат один. На сервере (ARM) — в последнем знаке float может быть разница. В облаке (Docker) — другая версия glibc меняет правила округления.

Sound говорит: "Этого не будет".

Философия проекта строится на концепции Golden Trace. Это не просто лог. Это эталонный журнал исполнения, который является частью спецификации. Если ваша программа на C выдала 0x1.8000000000000p+1 (число 3.0), а эталонный журнал говорит 0x1.8000000000001p+1 — программа неверна. Не "почти верна", а именно неверна.

Как это достигнуто? ANF и Побайтовая точность

Внутри Sound живет ядро SCore v0.3. Его главная фишка — A-Normal Form (ANF). В обычных языках компилятор может переставить инструкции ради оптимизации. В SCore каждое промежуточное вычисление имеет имя.

Было: x = (a + b) * c

Стало (ANF):

t1 = a + b
t2 = t1 * c

Этот порядок зафиксирован в структуре графа. Его нельзя изменить, не сломав детерминизм.

А чтобы числа были одинаковыми везде, Sound использует жесткую сериализацию: формат float.hex(). Никаких "умных" расширенных регистров x87 (80-bit). Только честные 64 бита IEEE-754, байт в байт.


2. Анатомия: Три слоя "луковицы"

Sound не монолитен. Это матрешка, где каждый слой решает свою задачу.

Слой 1: Спецификация (v0.1) — "Что должно быть истинно"

Это декларативный слой, похожий на SQL или Wolfram Language. Вы не пишете for или if. Вы пишете:

fact input -> Vector[F64, N];
rule process(x: Vector[F64, N]) -> Result[Vector[F64, N], DomainError];
wire output = process input;

Здесь нет императивного кода. Это чертеж системы.

Слой 2: Функциональное ядро (v0.2) — "Как считать внутри"

Здесь живут чистые функции, лямбды и вывод типов. Если спецификация — это схема, то этот слой — паяльник. Здесь мы пишем map, reduce и свои алгоритмы. Главное правило: никаких сайд-эффектов.

Слой 3: SCore (v0.3) — "Математика"

Это фундамент. Исчисление, в котором всего 6 типов значений (Int, Float, Bool, Vec, Closure, Err). Самое интересное здесь — ошибки как значения. В Sound нет try/catch. Если вы делите на ноль, вы не получаете Exception, который рвет стек. Вы получаете значение Err(DomainError). Оно просто течет дальше по графу как обычные данные.

"Если вычисление сломалось — это не повод падать, это повод передать эстафету ошибке дальше".


3. Мост в реальный мир: Trio и TRIOMAT

Sound не живет в вакууме. Ему нужно общаться с Python, Java и C. Здесь появляется Trio и формат TRIOMAT.

Забудьте про JSON и Protobuf для внутренних вычислений. TRIOMAT — это бинарный протокол с жесточайшим контрактом:

  1. Header: JSON (например, {"dtype":"Float64","shape":[100]}).

  2. Payload: Сырые байты в little-endian.

  3. Контракт: Если размерность в заголовке не совпадает с длиной данных — это Err(ShapeError), а не неопределенное поведение.

Это позволяет делать вещи, которые кажутся магией: вы считаете физику в Python (NumPy), передаете массив в Sound, он делает над ним матан и отдает в Java для визуализации. И на каждом этапе вы можете запустить diff журналов и увидеть, где именно потерялся один бит.


4. Зачем это инженеру? (Сферы применения)

Звучит академично, но Sound решает очень земные проблемы:

  • Встраиваемые системы (Embedded): Сгенерированный C99-код Sound не использует malloc. Он работает на STM32 без ОС. При этом он дает ту же точность, что и на сервере. А "партитура" (звуковой лог) позволяет инженеру на заводе услышать ошибку датчика по изменению тональности звука, не глядя в консоль.

  • Бухгалтерия и Финтех: В 1С или SAP копейки могут "гулять" из-за разницы версий СУБД. В Sound закрытие периода дает побайтово одинаковый Golden Trace. Если на боевом сервере лог отличается от тестового — система блокирует закрытие. Никаких "ой, мы округлили не туда".

  • Наука (Reproducible Research): Если вы описали алгоритм фильтрации сигнала на Sound, любой ученый в мире может взять вашу спецификацию, скомпилировать её и получить побитово тот же результат, что и вы, вне зависимости от своего железа.


5. Статус: Можно ли это использовать?

Проект находится в стадии v0.3.

  • Ядро (sound_core3.py): 75/75 тестов.

  • Оракул: 17 эталонных термов с побайтовой детерминантой.

  • C-бэкенд: Статические проверки пройдены (ALL CHECKS PASS). Зеркальный тест fmt_hex_double на 1.5 млн паттернов — 0 расхождений.

Единственный "OPEN" гейт: Финальный прогон скомпилированного C-кода через gcc для подтверждения RESULT: ALL TRACES MATCH.

Sound не пытается быть удобным для написания сайтов. Он пытается быть честным. В мире, где LLM генерируют код, который "выглядит правильно", Sound требует, чтобы код был математически верным.

Возможно, это и есть будущее "вайб-кодинга": мы описываем желание (промпт), а система вроде Sound гарантирует, что исполнение этого желания не нарушит законы физики и логики.


Репозиторий: github.com/lapkin25/sound

P.S. Если у вас под рукой есть gcc и 10 минут — авторы просят прогнать полный гейт. Единственный незакрытый вопрос проекта закрывается именно там.