Локальная генерация видео: ComfyUI и LTX-2.3

Раньше создание видео с помощью нейросетей было прерогативой облачных сервисов вроде Runway или Luma. Сегодня, если у вас есть современная видеокарта Nvidia, вы можете генерировать качественные ролики прямо на своем компьютере. В этой заметке я расскажу, как настроить локальную генерацию видео с помощью ComfyUI и эффективной модели LTX-2.3.

Инструменты для видео-генерации

Для работы нам понадобятся:
ComfyUI: мощный интерфейс с узловой архитектурой, который позволяет гибко настраивать процесс генерации.
LTX-2.3: современная модель от Lightricks, оптимизированная для создания плавных и детализированных видео при относительно умеренных требованиях к видеопамяти.

Требования к железу

Генерация видео — процесс куда более ресурсоемкий, чем работа с изображениями:
Видеокарта (GPU): Nvidia RTX с 8 ГБ VRAM — это необходимый минимум для разрешения 768×512. Для комфортной работы и более высоких разрешений крайне желательно иметь 16–24 ГБ VRAM.
Оперативная память (RAM): минимум 32 ГБ. Видео-модели и VAE занимают много места при загрузке.
Место на диске: около 500 ГБ для самой модели и сопутствующих компонентов.

Настройка и запуск

Процесс запуска LTX-2.3 в ComfyUI выглядит следующим образом:
1. Обновите ComfyUI: Модель относительно новая, поэтому убедитесь, что у вас установлена последняя версия интерфейса.
2. Установите Workflow: Самый простой способ — найти готовый JSON-шаблон для LTX Video. Модель требует специфических узлов для работы с латентным пространством видео.
3. Промпт и параметры: Введите описание сцены на английском языке. Обратите внимание, что LTX-2.3 хорошо понимает движение (например, “camera orbits around”, “fast movement”).

Почему стоит выбрать LTX-2.3?

LTX-2.3 примечательна тем, что она дает результат, сопоставимый с закрытыми облачными сервисами, но работает локально. Это дает вам:
Полную приватность: ваши промпты и сгенерированные видео не уходят на чужие сервера.
Контроль: вы можете экспериментировать с частотой кадров (FPS), разрешением и силой влияния промпта без необходимости платить за каждую попытку.

Локальная генерация видео всё еще находится в стадии активного развития, и LTX-2.3 — это отличный входной билет в мир “домашнего Голливуда”.

Ссылки

https://github.com/comfyanonymous/ComfyUI
https://huggingface.co/Lightricks/LTX-Video

Проброс портов между клиентами через Chisel: урезанный тоннель без L3

Когда два устройства находятся за NAT или строгими фаерволами и не могут “увидеть” друг друга напрямую, стандартным решением кажется VPN. Но полноценный L3-тоннель (вроде WireGuard или OpenVPN) часто избыточен: он требует root-прав, настройки виртуальных интерфейсов и может конфликтовать с существующими маршрутами.

В таких случаях удобно использовать Chisel — TCP/UDP тоннель, работающий поверх HTTP и использующий WebSockets для передачи данных. В этой заметке я покажу, как “прокинуть” порт от одного клиента к другому через промежуточный сервер.

Как это работает?

Представьте ситуацию: у вас есть Клиент А (например, ваш домашний сервер), Клиент Б (ваш рабочий ноутбук) и VPS с публичным IP-адресом. Клиенты А и Б могут обращаться к VPS, но не друг к другу.

Схема проброса будет выглядеть так:
1. Клиент А подключается к VPS и открывает “обратный” (reverse) порт на сервере. Теперь всё, что приходит на порт X сервера, попадает на порт Y Клиента А.
2. Клиент Б подключается к VPS и пробрасывает порт Z со своей локальной машины на порт X сервера.
3. В итоге Клиент Б обращается к localhost:Z и попадает на Клиент А:Y.

Такой подход — одно из решений в случаях, когда связь с VPS не реализует L3-слой или отсутствует возможность настройки маршрутизации между клиентами. Мы работаем исключительно на уровне приложений и портов.

Шаг 1: Запуск сервера

На вашей VPS достаточно запустить Chisel в режиме сервера. Флаг --reverse обязателен, чтобы разрешить клиентам открывать порты на стороне сервера.

chisel server --port 8080 --reverse

Шаг 2: Подключение Клиента А (Источник)

Допустим, Клиент А хочет открыть доступ к своему локальному веб-серверу на порту 3000. Он подключается к VPS и говорит: “зарезервируй на сервере порт 2000 и перенаправляй его мне на 3000”.

chisel client vps-ip:8080 R:2000:127.0.0.1:3000

Теперь порт 2000 на VPS (на loopback интерфейсе) ведет к Клиенту А.

Шаг 3: Подключение Клиента Б (Потребитель)

Теперь Клиент Б хочет получить доступ к этому ресурсу. Он подключается к той же VPS и пробрасывает свой локальный порт 8080 на порт 2000 сервера.

chisel client vps-ip:8080 8080:127.0.0.1:2000

Готово! Теперь открыв http://localhost:8080 на Клиенте Б, вы увидите сервис, запущенный на Клиенте А.

Безопасность и нюансы

Chisel поддерживает аутентификацию через флаг --auth, что крайне рекомендуется при работе через публичные сервера. Также можно использовать TLS-сертификаты для шифрования трафика.

Главное преимущество такого подхода — отсутствие необходимости в TUN/TAP устройствах и сложных таблицах маршрутизации. Это “урезанный” тоннель, который делает ровно одну вещь: связывает порты через WebSocket-соединение. Это работает даже через корпоративные прокси, если настроить Chisel на работу через 443 порт.

Вывод

Chisel — это утилита для специфических сетевых задач. Когда нужно прокинуть порты между изолированными узлами без настройки полноценного VPN, связка из прямого и обратного тоннелей через релей-сервер оказывается вполне жизнеспособным решением.

Ссылки

https://github.com/jpillora/chisel

Локальный Vibe-кодинг: LM Studio, VS Code и Continue

Если у вас было желание использовать нейросети для помощи в написании кода (так называемый Vibe-кодинг), и у вас достаточно мощный компьютер, например с видеокартой Nvidia RTX, то вы можете развернуть всю среду абсолютно бесплатно на своей машине. Это решает проблемы с платными подписками и позволяет спокойно работать с проектами под NDA, так как ваш код никуда не отправляется. В этой заметке я опишу, как собрать локальную связку из LM Studio, VS Code и расширения Continue.

Инструменты для локального Vibe-кодинга

Для комфортной работы нам понадобятся три основных компонента:
LM Studio: удобное приложение для загрузки и запуска локальных LLM. Оно берет на себя всю сложность работы с GGUF-моделями и поднимает локальный сервер, совместимый с API OpenAI.
VS Code: популярный и привычный редактор кода.
Continue: расширение для VS Code, которое интегрирует нейросети прямо в рабочую среду. Позволяет общаться в чате, выделять код для рефакторинга и поддерживает автодополнение (autocomplete).

Требования к железу

Локальные языковые модели требовательны к памяти:
Видеокарта (GPU): Nvidia с 8 ГБ VRAM и выше (для комфортной работы с моделями на 7-8 миллиардов параметров). Для более тяжелых моделей потребуется от 16 ГБ VRAM.
Место на диске: около 500 ГБ для хранения разных скачанных моделей.

Настройка связки

Процесс настройки достаточно прост и не требует сложных манипуляций в терминале:
1. Скачайте и установите LM Studio. Во встроенном поиске найдите легковесную модель, например Qwen Coder или gemma3:12b.
2. В LM Studio перейдите во вкладку Local Server и нажмите Start Server. По умолчанию он запустится на `http://localhost:1234/v1`.
3. Откройте VS Code и установите расширение Continue из магазина плагинов.
4. Откройте конфигурационный файл Continue и добавьте новую модель, указав провайдера `openai` и адрес вашего локального сервера из LM Studio.

После этого вы сможете общаться с локальной LLM прямо в сайдбаре Continue, задавать вопросы по вашему коду и генерировать новые компоненты.

Почему это работает?

Как я уже писал ранее, LLM лучше справляются с плоской структурой и WET-кодом (Write Everything Twice). Локальные модели параметров могут уступают гигантам вроде GPT-4 в проектировании сложных архитектур, но для генерации шаблонного кода, рефакторинга простых функций и быстрого прототипирования их возможностей более чем достаточно.

Кроме того, при локальном Vibe-кодинге ваш код не покидает пределы машины. Это делает такую связку идеальной для корпоративной разработки и работы с чувствительными данными.

Вывод

Локальные нейросети не способны полноценно заменить программиста или спроектировать сложную систему. Тем не менее, связка LM Studio + VS Code + Continue дает независимость от облачных сервисов и сохраняет приватность. Это вполне рабочий вспомогательный инструмент для рутинных задач, если вы готовы мириться с ограничениями небольших моделей и самостоятельно контролировать архитектуру проекта.

Ссылки

https://code.visualstudio.com/
https://lmstudio.ai/
https://continue.dev/

Источники

https://youtu.be/IqqCwhG46jY
https://www.youtube.com/watch?v=7AImkA96mE8

Локальная генерация музыки: ComfyUI и модель ACE-Step-1.5

В наше время не обязательно полагаться на облачные сервисы для создания контента: вы можете генерировать высококачественную музыку полностью на своем железе. В этой заметке я опишу, как запустить современную модель ACE-Step-1.5 локально на вашем компьютере с помощью ComfyUI.

ComfyUI использует узловую (node-based) архитектуру. Это позволяет:
– Тотально контролировать каждый этап генерации аудио.
– Легко обмениваться готовыми “рабочими процессами” (workflows).

ACE-Step-1.5 — это продвинутая модель для генерации музыки, требующая значительных вычислительных ресурсов. Требования к железу выше, чем у многих простых синтезаторов:
Видеокарта (GPU): Nvidia RTX с 8 ГБ VRAM и выше (рекомендуется 12 ГБ+) для комфортной работы при высоком качестве.
Оперативная память (RAM): минимум 16 ГБ (лучше 32 ГБ и выше).
Процессор (CPU): Современный многоядерный процессор с хорошей поддержкой AVX/CUDA вычислений.
Место на диске: около 20–50 ГБ для моделей и компонентов.

Самый простой способ запустить ACE-Step-1.5 — использовать готовый шаблон аудиогенерации. Просто найдите music text to audio в окне workflows и установите.

Напишите промпт, описывающий жанр и настроение (например, “uplifting synthwave track with heavy bass”), в узле `Prompt Input`. Укажите желаемую длительность и нажмите RUN.
Первая генерация может занять время, так как модели будут загружаться в память видеокарты и обрабатывать сложные акустические паттерны.

https://github.com/comfyanonymous/ComfyUI
https://www.youtube.com/watch?v=UAlLD5fS7-c

Raspberry PI 3 как Wi-Fi роутер

В сети очень много статей как сделать из Raspberry Pi (RPI) Wi-Fi роутер, в этой заметке я кратко опишу свой способ создания Wi-Fi роутера с sing-box на борту. Описанный метод работает на текущий момент времени, и многое может измениться в будущем. Поэтому используйте эту заметку для примерного обзорного понимания того с чем предстоит столкнуться.

SSH

Для тех кто не умеет работать с OpenWrt, я рекомендую установить dietPI.
Подключите RPI к вашему текущему роутеру по eth0, далее подключитесь туда по SSH. Узнать ip адрес RPI можно в dhcp панели роутера. Подключайтесь сразу к root, например так:

ssh root@[IP_ADDRESS]

Точка доступа

По умолчанию dietPI для root ставит пароль dietpi. После подключения вас встретит установщик/конфигуратор dietPI. По окончанию нужно будет подключиться снова из-за перезагрузки устройства.

Для начала вам нужно настроить hostapd для того чтобы устройства видели вашу точку доступа. Если hostapd не установлен, то установите его через apt.

Далее нужно будет написать конфиг для hostapd. Пример моего конфига:

interface=wlan0
driver=nl80211
ssid=MyPiAP
hw_mode=a
channel=157
wmm_enabled=1

auth_algs=1
wpa=2
wpa_passphrase=your_password
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP
ieee80211n=1
ieee80211ac=0
ieee80211ax=0
country_code=RU

Смысл конфига hostapd можно посмотреть в мануале. Однако из того что важно стоит настроить под себя – канал (2.4GHz или 5GHz), код страны, иначе без этого ваши локализованные устройства могут работать с точкой доступа корректно, это я уже проходил и знаю, поэтому установите свою страну обязатально.

DHCP

Далее установите и настройте dnsmasq для реализации DHCP. Это нужно для того чтобы подключенные компьютеры определяли ip адрес и dns сервера.
Пример моего конфига:

interface=wlan0
dhcp-range=172.19.0.10,172.19.0.200,255.255.255.0,12h

dhcp-option=3,172.19.0.1

dhcp-option=6,1.1.1.1,8.8.8.8

no-resolv

server=1.1.1.1
server=8.8.8.8

Это минимальный конфиг, который позволит подключиться к точке доступа и получить ip адрес. Далее вам нужно будет настроить маршрутизацию и NAT. Это нужно для того чтобы подключенные компьютеры могли выходить в интернет.

Здесь уже заметка переходит в разряд типичной настройки маршрутизации на обычной debian совместимой системе, о чем есть очень много статей в сети. Далее все зависит от того какие цели вы преследуете, например подключение к внешнему серверу как новому интерфейсу в системе, или просто делаете wlan0 <-> eth0, на этом специфика по RPI заканчивается, дальше настраивайте на свой вкус.

Хочется упомянуть также необходимость настройки кастомных системных сервисов через systemctl, возможно появится потребность в подключении сервисов по цепочке, все это есть в мануалах по systemctl в сети. Если возникли проблемы на уровне сервисов, то ознакомьтесь с логами в journalctl.

Wi-Fi адаптер

Встроенный в RPI3 оказался откровенно слабым и не поддерживающим 5GHz. Поэтому я подключил адаптер RITMIX RWA-150 на чипсете Realtek RTL8811CU через USB 2. Драйвера добавлены в ядро Linux которое было в моей версии dietPi. Далее с помощью dietpi-config отключил встроенный Wi-Fi полностью. В результате этого остался один wlan0 адаптер по USB.

Заключение

Из замеров скорости удалость выжать из RPI3 около 50Мбит/с по Wi-Fi (после подключения 5GHz адаптера) что означает потерю половины скорости по сравнению с подключением напрямую к роутеру. Допускаю что более производительные модели RPI позволят добиться лучших результатов, также специализированные устройства на OpenWrt и готовые решения могут оказаться лучше для ваших потребностей.

Источники

https://forums.raspberrypi.com/viewtopic.php?t=394710
https://superuser.com/questions/1408586/raspberry-pi-wifi-hotspot-slow-internet-speed
https://www.youtube.com/watch?v=jlHWnKVpygw

Локальная генерация изображений: ComfyUI и модель FLUX

В наше время не обязательно полагаться на облачные сервисы: вы можете генерировать высококачественные изображения полностью на своем железе. В этой заметке я опишу, как запустить современную модель FLUX локально на вашем компьютере с помощью ComfyUI.

ComfyUI использует узловую (node-based) архитектуру. Это позволяет:
– Тотально контролировать каждый этап генерации.
– Легко обмениваться готовыми “рабочими процессами” (workflows)

FLUX — модель крупная, поэтому требования к железу выше, чем у SD 1.5 или SDXL:
Видеокарта (GPU): Nvidia RTX с 12 ГБ VRAM и выше (для комфортной работы). Если у вас 8 ГБ или меньше, придется использовать квантованные версии (GGUF или NF4).
Оперативная память (RAM): минимум 16 ГБ (лучше 32 ГБ и выше).
Место на диске: около 20–50 ГБ для моделей и компонентов.

Самый простой способ запустить FLUX — использовать готовый шаблон. Просто найдите flux text to image в окне workflows и установите.

Напишите промпт на английском языке в узле `Text to Image (Flux.1 Dev)`, выберите разрешение (FLUX отлично справляется с 1024×1024 и даже выше) и нажмите RUN.

Первая генерация может занять время, так как модели будут загружаться в память видеокарты.

https://github.com/comfyanonymous/ComfyUI

Mars Miners v2

[Экстренный выпуск: Интерпланетарная служба новостей «Красный Горизонт»]

ВЕДУЩИЙ: Доброй ночи, Марс! С вами служба новостей главного купола. Сегодня администрация колонии Mars Miners объявила о масштабном обновлении программного обеспечения для всех поселенцев и стратегических модулей.

ОСНОВНЫЕ СОБЫТИЯ:

1. Обновление нейронных цепей автоматонов Отдел кибернетики подтвердил успешную прошивку всех автономных шахтерских юнитов. Новые протоколы стратегического мышления исключают критические ошибки в логике застройки. Теперь симуляция конкуренции за ресурсы станет еще более непредсказуемой и жесткой. Поселенцы могут самостоятельно задавать время тактического анализа для своих ИИ-партнеров.

2. Интеграция виртуальных учебных полигонов Для новоприбывших колонистов открыт доступ к персональным тренировочным симуляторам. Теперь вы можете оттачивать навыки захвата секторов в одиночном режиме, прежде чем вступать в реальную борьбу за марсианские рудники. Система снабжена обновленными протоколами инструктажа.

3. Стабилизация каналов связи между куполами Инженеры связи завершили калибровку спутниковой группировки. Многопользовательский интерфейс взаимодействия между удаленными аванпостами теперь работает без задержек. Устранены аномалии, приводившие к разрывам соединения во время проведения стратегических операций.

4. Подсознательный расчет: обновление нейроспусков Технический департамент внедрил систему параллельных вычислений. Теперь обработка тактических данных ИИ происходит в фоновом режиме, не нагружая центральные процессоры ваших персональных терминалов. Больше никаких пауз во время критических фаз игры.

ВЕДУЩИЙ: Администрация напоминает, что новая версия игровых симуляторов уже загружена в центральный терминал. Для синхронизации данных рекомендуется перезагрузить ваши локальные интерфейсы.

Будущее Марса — в ваших руках. Оставайтесь с нами на частоте «Красного Горизонта».

https://demensdeum.com/games/mars-miners/

Запуск macOS в Docker

macOS возможно запустить в Docker, несмотря на возражения людей которые говорят что это невозможно, и якобы macOS обладает какими-то системами защиты которые могут этому противостоять.

Одними из классических способов запуска macOS на PC машинах исторически были:
* Hackintosh
* Виртуализация, например с помощью VMWare

Hackintosh предполагает наличие аналогичного или очень близкого к оригинальному маку железа. Виртуализация же предъявляет определенные требования к оборудованию, но в основном не такие строгие как в случае с Hackintosh. При этом в случае с виртуализацией есть проблемы с производительностью, так как macOS не оптимизирована для работы в виртуальной среде.

С недавних пор появилась возможность запускать macOS в Docker. Это стало возможным благодаря проекту Docker-OSX, который предоставляет готовые образы macOS для запуска в Docker. При этом стоит отметить, что Docker-OSX не является официальным проектом Apple и не поддерживается ею. Тем не менее, он позволяет запускать macOS в Docker и использовать ее для разработки и тестирования приложений.

Один из первых проектов по запуску macOS в Docker:
https://github.com/sickcodes/Docker-OSX

Однако запустить полноценно мне так и не удалось, после загрузки в мено Recovery OS, у меня просто отваливалась клавиатура и мышь, и я не мог продолжить установку. При этом в первом boot меню, клавиатура работает. Возможно дело в том что этот проект уже не так активно поддерживается, и есть некие специфические проблемы при запуске на Windows 11 + WSL2 + Ubuntu.

Один из самых активных проектов на данный момент:
https://github.com/dockur/macos

Позволяет запускать macOS в Docker, интерфейс работает через браузер путем проброса VNC(?). После запуска macOS доступна по адресу http://localhost:5900

Данный проект мне удалось запустить и установить macOS Big Sur (минуточку 2020 года) на Windows 11 + WSL2 + Ubuntu, но только изменив compose файл, а именно:

environment:
    VERSION: "11"
    RAM_SIZE: "8G"
    CPU_CORES: "4"

VERSION: “11” – это версия macOS, в данном случае Big Sur
RAM_SIZE: “8G” – это объем оперативной памяти, выделяемый для macOS
CPU_CORES: “4” – это количество ядер процессора, выделяемых для macOS

На текущий момент запуск macOS tahoe (16) также возможен, но есть ряд проблем которые пытаются доблестно решить разработчики проекта.

Такой оригинальный способ запуска macOS позволяет попробовать ее на своем не мак железе и вдоволь намучившись, пойти и купить себе мак. Однако может пригодиться для тестирования ПО на старых системах и общего развития.

Сборка Swift в WSL2 (Linux)

Экосистема Swift активно развивается за пределами платформ Apple, и сегодня писать на нём под Windows вполне комфортно, используя Windows Subsystem for Linux (WSL2). Стоит учитывать, что для сборок под Linux/WSL доступен облегченный вариант Swift — без проприетарных Apple-фреймворков (таких как SwiftUI, UIKit, AppKit, CoreData, CoreML, ARKit, SpriteKit и других специфичных для iOS/macOS библиотек), однако для консольных утилит и бэкенда этого более чем достаточно. В этой заметке мы шаг за шагом разберём процесс подготовки окружения и сборки компилятора Swift из исходных кодов внутри WSL2 (на примере Ubuntu/Debian).

Обновляем список пакетов и саму систему:

sudo apt update && sudo apt upgrade -y

Устанавливаем необходимые зависимости для сборки:

sudo apt install -y \
  git cmake ninja-build clang python3 python3-pip \
  libicu-dev libxml2-dev libcurl4-openssl-dev \
  libedit-dev libsqlite3-dev swig libncurses5-dev \
  pkg-config tzdata rsync

Устанавливаем компилятор и компоновщик (LLVM и LLD):

sudo apt install -y llvm lld

Клонируем репозиторий Swift со всеми зависимостями:

git clone https://github.com/apple/swift.git
cd swift
utils/update-checkout --clone

Устанавливаем `swiftly` и готовый swift с swiftc

curl -O https://download.swift.org/swiftly/linux/swiftly-$(uname -m).tar.gz && \
tar zxf swiftly-$(uname -m).tar.gz && \
./swiftly init --quiet-shell-followup && \
. "${SWIFTLY_HOME_DIR:-$HOME/.local/share/swiftly}/env.sh" && \
hash -r

Запускаем сборку (это займёт продолжительное время):

utils/build-script \
  --release-debuginfo \
  --swift-darwin-supported-archs="x86_64" \
  --llvm-targets-to-build="X86" \
  --skip-build-benchmarks \
  --skip-test-cmark \
  --skip-test-swift \
  --skip-ios \
  --skip-tvos \
  --skip-watchos \
  --skip-build-libdispatch=false \
  --skip-build-cmark=false \
  --skip-build-foundation \
  --skip-build-lldb \
  --skip-build-xctest \
  --skip-test-swift

После завершения сборки добавляем путь к компилятору в PATH (укажите ваш путь до папки сборки):

export PATH=/root/Sources/3rdparty/build/Ninja-RelWithDebInfoAssert/swift-linux-x86_64/bin/swiftc:$PATH

Проверяем, что установленная версия Swift работает:

swift --version

Создаём тестовый файл и запускаем его:

echo "print(\"Hello, World!\")" > hello.swift
swift hello.swift

Также можно скомпилировать бинарный файл и запустить его:

swiftc hello.swift
./hello

Источники

Teflecher

Teflecher — это быстрое, интерактивное, кроссплатформенное приложение-викторина, созданное на основе Kotlin Multiplatform (KMP) и Compose Multiplatform. Оно позволяет пользователям интуитивно загружать викторины из локальных JSON-файлов или удаленных URL-адресов, отвечать на вопросы с несколькими вариантами ответа, мгновенно видеть обратную связь о правильности ответов и отслеживать свои результаты.

Web:
https://demensdeum.com/software/teflecher/

GitHub:
https://github.com/zefir1990/teflecher

Также редактор квизов формата Teflecher Editor на основе технологий Ionic + Capacitor

Web:
https://demensdeum.com/software/teflecher-editor/

GitHub:
https://github.com/zefir1990/teflecher-editor

Паттерн Интерпретатор на практике

В прошлой статье мы разобрали теорию паттерна Интерпретатор, узнали что такое AST-дерево и как абстрагировать терминальные и нетерминальные выражения. На этот раз давайте отойдем от теории и посмотрим, как этот паттерн применяется в серьезных коммерческих проектах, которыми мы все пользуемся ежедневно!

Спойлер: Вы, возможно, пользуетесь паттерном Интерпретатор прямо сейчас, просто читая этот текст в браузере!

Один из самых ярких и, пожалуй, самых важных примеров использования этого паттерна в индустрии — это JavaScript. Язык, который изначально создавался “на коленке”, сегодня работает на миллиардах устройств именно благодаря концепции интерпретации.

10 дней, которые перевернули интернет

История создания JavaScript полна легенд. В 1995 году Брендан Эйх (Brendan Eich), работая в Netscape Communications, получил задание: создать простой скриптовый язык, который мог бы выполняться прямо в браузере (Netscape Navigator), чтобы делать веб-странички интерактивными. Руководство хотело что-то с синтаксисом, похожим на сверхпопулярный тогда Java, но предназначенное не для профессиональных инженеров, а для веб-дизайнеров.

У Эйха было всего 10 дней на написание первого прототипа языка, который тогда назывался Mocha (затем LiveScript, и только потом JavaScript из маркетинговых соображений). Спешка была не случайной: на пятки наступала корпорация Microsoft, которая в это же время активно готовила свой собственный скриптовый язык VBScript для встраивания в браузер Internet Explorer. Netscape нужно было срочно выпустить свой ответ, чтобы не проиграть в надвигающейся браузерной войне.

Времени писать сложный компилятор в машинный код просто не было. Очевидным и самым быстрым решением для Эйха стала архитектура классического Интерпретатора.

Первый интерпретатор (SpiderMonkey) работал так:

  1. Он читал текстовый исходный код скрипта со страницы.
  2. Лексический анализатор разбивал текст на токены.
  3. Парсер строил Абстрактное Синтаксическое Дерево (AST). В терминах паттерна Интерпретатор это дерево состояло из терминальных выражений (строки, числа вроде 42) и нетерминальных (вызовы функций, операторы вроде If, While).
  4. Затем виртуальная машина шаг за шагом “обходила” это дерево, выполняя заложенные в нем инструкции у каждого узла (вызывая метод, аналогичный Interpret()).

Контекст (Context) и Объекты

Помните объект Context, который мы должны были передавать в метод Interpret(Context context) в классической реализации? Он нужен интерпретатору для хранения текущего состояния памяти.

В случае с JavaScript роль этого контекста на верхнем уровне играет Глобальный объект (например, window в браузере). Когда ваш AST-узел пытается, скажем, вывести текст на экран через document.write(“Hello”), интерпретатор обращается к своему контексту (объекту document) и вызывает нужный внутренний API браузера.

Именно благодаря интерпретатору JavaScript смог так легко взаимодействовать с DOM (Document Object Model) — всё это просто объекты в контексте, к которым обращаются узлы дерева.

Эволюция интерпретатора: JIT Компиляция

Исторически JS в браузерах долгое время оставался “чистым” интерпретатором. И у этого был большой минус — медленная скорость. Парсинг дерева и медленный обход каждого узла при каждом выполнении скрипта тормозил сложные веб-приложения.

С появлением движка V8 от Google (встроенного в Chrome) в 2008 году произошла революция. Инженеры поняли, что одного интерпретатора недостаточно для современного веба. Движок усложнился: он по-прежнему строит AST-дерево, но теперь использует JIT (Just-In-Time) компиляцию.

Современные JS-движки (V8, SpiderMonkey) работают как сложный конвейер:

  1. Быстрый и “тупой” базовый интерпретатор начинает выполнять ваш JS код моментально, даже не дожидаясь его компиляции (здесь по-прежнему работает классический паттерн).
  2. Параллельно, движок отслеживает “горячие” участки кода (циклы или функции, которые вызываются тысячи раз).
  3. Эти участки компилируются JIT-компилятором напрямую в оптимизированный машинный код, минуя медленный интерпретатор.

Именно это сочетание моментального старта интерпретатора и вычислительной мощи компиляции позволило JavaScript захватить мир, став языком серверов (Node.js) и мобильных приложений (React Native).

Интерпретатор в игровой индустрии

Несмотря на доминирование C++ в тяжелых вычислениях, паттерн Интерпретатор является индустриальным стандартом в геймдеве для создания игровой логики. Зачем? Чтобы геймдизайнеры могли делать игры без риска «уронить» движок или необходимости его постоянно перекомпилировать.

Отличным историческим примером является UnrealScript — язык, на котором была написана логика игр серий Unreal Tournament и Gears of War в Unreal Engine 1, 2 и 3. Текст компилировался в компактный байт-код абстрактной машины, который затем шаг за шагом 해석(интерпретировался) виртуальной машиной движка.

Визуальные граф-скрипты (Blueprints)

Сегодня на смену тексту пришло визуальное программирование — система Blueprints в Unreal Engine 4 и 5.

Если вы когда-либо открывали Blueprint в Unreal Engine, вы видели множество блоков-узлов (Nodes), соединенных «проводами». Архитектурно, весь граф Blueprints — это огромное Абстрактное Синтаксическое Дерево (AST), нарисованное на экране:

  1. Терминальные выражения (Terminal Expressions): Узлы-константы. Например, узел, который просто хранит число 42 или строку. Они возвращают конкретное значение при интерпретации.
  2. Нетерминальные выражения (Non-Terminal Expressions): Вычислительные узлы (сложение Add) или узлы контроля потока (Branch). У них есть входы-аргументы, которые интерпретатор сначала рекурсивно вычисляет, прежде чем выдать результат на выходной пин.

А роль контекста здесь играет память экземпляра конкретного игрового объекта (Actor). Interpreter Machine безопасно “гуляет” по этому графу, запрашивая данные и выполняя переходы.

Где еще используется Интерпретатор?

Паттерн интерпретатор можно найти практически в любой сложной системе, где требуется выполнять динамические инструкции. Вот лишь несколько примеров из коммерческого ПО:

  • Интерпретируемые языки программирования (Python, Ruby, PHP). Весь их рантайм базируется на классическом паттерне. Например, эталонная реализация CPython сначала парсит ваш .py скрипт в AST, компилирует его в байт-код, а затем огромная виртуальная машина (цикл вычисления) интерпретирует этот байт-код шаг за шагом.
  • Java Virtual Machine (JVM). Изначально Java код компилируется не в машинные инструкции, а в байт-код. Когда вы запускаете приложение, JVM работает как интерпретатор (правда, с агрессивной JIT-компиляцией, как и в V8).
  • Базы данных и SQL. Когда вы отправляете SQL-запрос (SELECT * FROM users) в PostgreSQL или MySQL, движок базы данных выступает в роли интерпретатора. Он проводит лексический анализ, строит AST-дерево запроса, генерирует план выполнения и затем буквально «интерпретирует» этот план, перебирая строки таблиц.
  • Регулярные выражения (RegEx). Любой движок регулярных выражений внутри парсит строковый паттерн (например, ^\d{3}-\d{2}$) в граф состояний (NFA/DFA Автомат), по которому затем проходит внутренний интерпретатор, сопоставляя каждый вводимый символ с вершинами этого графа.
  • Unity Shader Graph / Unreal Material Editor — интерпретируют визуальные узлы в модульный шейдерный код (GLSL/HLSL).
  • Blender Geometry Nodes — интерпретируют математические и геометрические операции для процедурной генерации 3D-моделей в реальном времени.

Итог

Паттерн Интерпретатор давно вышел за рамки «написать свой калькулятор». Это мощнейший индустриальный стандарт. От JavaScript-движков, которые ежедневно исполняют гигабайты кода за кулисами браузеров, до игровых конструкторов, позволяющих строить сложную логику без знания C++ — интерпретаторы остаются одной из важнейших архитектурных концепций в современной IT-разработке.

Glazki TV: Современный плеер для интернет-телевидения

Glazki TV — это современный, высокопроизводительный плеер для интернет-телевидения (IPTV), построенный на базе React Native и Expo. Проект ориентирован на простоту использования и скорость работы, предоставляя удобный интерфейс для просмотра IPTV-каналов как на мобильных устройствах, так и в браузере.

Основные возможности

  • 📺 Просмотр каналов: Просматривайте тысячи каналов, разделенных по категориям для удобной навигации.
  • 🔍 Поиск: Быстро находите нужные каналы по названию.
  • ❤️ Избранное: Сохраняйте любимые каналы для быстрого доступа (данные сохраняются локально).
  • 🔗 Deep Linking: Делитесь прямыми ссылками на каналы, которые открываются автоматически.
  • 🌓 Поддержка тем: Интерфейс автоматически адаптируется к системной темной или светлой теме.
  • 🌐 Веб-поддержка: Плеер полностью функционален в браузере с синхронизацией URL.

Технологический стек

В основе проекта лежат современные инструменты разработки:

  • Framework: React Native + Expo
  • Video Player: expo-video (замена устаревшему expo-av)
  • UI Toolkit: react-native-paper
  • Playlist Parser: iptv-playlist-parser

Веб версия:
https://demensdeum.com/software/glazki-tv/

Google Play версия:
https://play.google.com/store/apps/details?id=com.demensdeum.glazkitv

Проект продолжает развиваться, и я буду рад любой обратной связи!

Пламенная сталь: Маска смерти 2

В тусклых, мерцающих неоном глубинах цифрового преступного мира ждет новый вызов. Мы рады приоткрыть занавес Flame Steel: Death Mask 2, многопользовательской 3D-игры по подземельям, сочетающей эстетику ретро-киберпанка с современным игровым процессом в реальном времени.

🕹️ Что такое Flame Steel: Death Mask 2?

Представьте себе, что вы просыпаетесь в процедурно сгенерированном лабиринте, где каждая тень может быть другим игроком или враждебной сущностью «Фильтр». Flame Steel: Death Mask 2 ставит вас на место Искателя, путешествующего по миру, построенному на Flame Steel Engine 2 и Three.js.

В настоящее время игра находится на ранней стадии разработки, но основной опыт уже доступен и готов к исследованию.

🚀 Ключевые особенности

<ул>

  • Исследование в многопользовательском режиме: вы не одиноки в сетке. Наблюдайте за другими игроками в режиме реального времени, перемещаясь по лабиринтным коридорам.
  • Процедурные подземелья: нет двух одинаковых прохождения. Сервер генерирует свежие карты, наполненные тайнами и опасностями.
  • Терминал. Для тех, кто предпочитает более «практический» подход, встроенный интерфейс командной строки позволяет напрямую взаимодействовать с системой — выполнять сложные действия, выполнять отладку или просто общаться с другими Искателями.
  • Боевые действия и усиление; Выживание: сразитесь с фильтрами, чтобы заработать биты, а затем используйте их, чтобы разблокировать сундуки и улучшить свою статистику. Следите за своим здоровьем; выживание не гарантировано.
  • Эстетика ретро-киберпанка: высококонтрастная графика и суровая атмосфера, отдающая дань уважения классической эпохе киберпанка.
  • 🛠️ Технология за маской

    Игра, созданная для браузера, использует:

    <ул>

  • Внешний интерфейс: стандартный JavaScript и Three.js для плавного 3D-рендеринга.
  • Бэкэнд: Node.js и WebSockets (ws) для молниеносной многопользовательской синхронизации.
  • Инфраструктура: MongoDB для сохранения данных и Redis для пространственной индексации в реальном времени.
  • 🗺️ Что дальше?

    Мы только начинаем. Будучи проектом с ранним доступом, Death Mask 2 будет получать частые обновления, в том числе:

    <ул>

  • Новые типы сущностей и сложная боевая механика.
  • Более глубокие знания и повествование об окружающей среде.
  • Расширенные команды терминала и социальные функции.
  • Визуализация и улучшение производительности.
  • 🔗 Присоединяйтесь к сетке

    Хотите проверить свои силы? Введите свое кодовое имя и инициализируйте свою личность сегодня:

    👉 Играть в Flame Steel: Death Mask 2

    Следите за новостями, поскольку мы продолжаем расширять границы цифровых технологий. Добро пожаловать в сервис. Это требует вас.

    Ushki Radio Google Play

    Ushki-Radio — это кроссплатформенный радиоплеер для онлайн-радио, сделанный с упором на простоту и удовольствие от прослушивания. Без лишних функций, без перегруженных интерфейсов — просто включил и слушаешь.

    Релиз в Google Play:

    https://play.google.com/store/apps/details?id=com.demensdeum.ushkiradio

    Ushki Radio

    Ushki-Radio — это кроссплатформенный радиоплеер для онлайн-радио, сделанный с упором на простоту и удовольствие от прослушивания. Без лишних функций, без перегруженных интерфейсов — просто включил и слушаешь.


    https://demensdeum.com/software/ushki-radio

    Проект использует открытую базу Radio Browser, благодаря чему в приложении доступны тысячи радиостанций со всего мира. Их можно искать по названию, жанрам или популярности, добавлять в избранное и быстро возвращаться к любимым станциям.

    Ushki-Radio отлично подходит именно для роли фонового радиоплеера: он запоминает последнюю станцию, позволяет управлять громкостью и не требует сложной настройки. Интерфейс лаконичный и понятный — всё сделано так, чтобы ничего не отвлекало от музыки, разговоров и эфира.

    Технически проект построен на React Native и Expo, поэтому работает как в браузере, так и в виде нативного приложения. Под капотом используется expo-av для воспроизведения аудио, а пользовательские настройки хранятся локально. Есть поддержка нескольких языков, включая русский и английский.

    Ushki-Radio — это хороший пример того, каким может быть современный интернет-радиоплеер: открытый, лёгкий, расширяемый и ориентированный в первую очередь на слушателя. Проект распространяется под лицензией MIT и отлично подойдёт как для личного использования, так и как база для собственных экспериментов с аудио-приложениями.

    GitHub:
    https://github.com/demensdeum/Ushki-Radio

    Coverseer

    Coverseer — интеллектуальный наблюдатель за процессами с помощью LLM

    Coverseer — это CLI-инструмент на Python, предназначенный для интеллектуального мониторинга и автоматического перезапуска процессов. В отличие от классических watchdog-решений, он анализирует текстовый вывод приложения с помощью LLM-модели и принимает решения на основе контекста, а не только кода завершения.

    Проект распространяется с открытым исходным кодом и доступен на GitHub:
    https://github.com/demensdeum/coverseer

    Что такое Coverseer

    Coverseer запускает указанный процесс, непрерывно отслеживает его stdout и stderr, передаёт последние фрагменты вывода в локальную LLM-модель (через Ollama) и определяет, находится ли процесс в корректном рабочем состоянии.

    Если модель определяет ошибку, зависание или некорректное поведение, Coverseer автоматически завершает процесс и запускает его заново.

    Ключевые особенности

    • Контекстный анализ вывода — вместо проверки exit code используется анализ логов с помощью LLM
    • Автоматический перезапуск — процесс перезапускается при обнаружении проблем или аварийного завершения
    • Работа с локальными моделями — используется Ollama, без передачи данных во внешние сервисы
    • Подробное логирование — все действия и решения фиксируются для последующей диагностики
    • Standalone-исполнение — возможно упаковать в единый исполняемый файл (например, .exe)

    Как это работает

    1. Coverseer запускает команду, переданную через CLI
    2. Собирает и буферизует текстовый вывод процесса
    3. Отправляет последние строки в LLM-модель
    4. Получает семантическую оценку состояния процесса
    5. При необходимости завершает и перезапускает процесс

    Такой подход позволяет выявлять проблемы, которые невозможно обнаружить стандартными средствами мониторинга.

    Требования

    • Python 3.12 или новее
    • Установленная и запущенная Ollama
    • Загруженная модель gemma3:4b-it-qat
    • Python-зависимости: requests, ollama-call

    Пример использования


    python coverseer.py "your command here"

    Например, наблюдение за загрузкой модели Ollama:


    python coverseer.py "ollama pull gemma3:4b-it-qat"

    Coverseer будет анализировать вывод команды и автоматически реагировать на сбои или ошибки.

    Практическое применение

    Coverseer особенно полезен в сценариях, где стандартные supervisor-механизмы недостаточны:

    • CI/CD пайплайны и автоматические сборки
    • Фоновые сервисы и агенты
    • Экспериментальные или нестабильные процессы
    • Инструменты с большим объёмом текстовых логов
    • Dev-среды, где важна самовосстанавливаемость

    Почему LLM-подход эффективнее

    Классические системы мониторинга реагируют на симптомы. Coverseer анализирует поведение. LLM-модель способна распознавать ошибки, предупреждения, повторяющиеся сбои и логические тупики даже в тех случаях, когда процесс формально продолжает работать.

    Это делает мониторинг более точным и снижает количество ложных срабатываний.

    Заключение

    Coverseer — это наглядный пример практического применения LLM в DevOps-и автоматизационных задачах. Он расширяет традиционное понимание мониторинга процессов и предлагает более интеллектуальный, контекстно-ориентированный подход.

    Проект будет особенно интересен разработчикам, которые экспериментируют с ИИ-инструментами и ищут способы повысить устойчивость своих систем без усложнения инфраструктуры.

    Flame Steel: Mars Miners

    Flame Steel: Mars Miners — это тактическая стратегия с необычным темпом и акцентом на принятие решений, а не на рефлексы. Игра разворачивается на Марсе, где игроки соревнуются за контроль над ресурсами и территориями в условиях ограниченной информации и постоянного давления со стороны соперников.

    В основе геймплея — строительство станций-узлов, которые формируют инфраструктуру вашей экспедиции. Узлы позволяют добывать ресурсы, расширять зону влияния и выстраивать логистику. Каждое размещение имеет значение: одна ошибка может открыть противнику путь к ключевым секторам или лишить вас стратегического преимущества.

    Ритм игры намеренно выверенный и напряжённый. Он находится где-то между шахматами, го и морским боем: здесь важно позиционирование, прогнозирование действий оппонента и умение работать с неопределённостью. Часть карты и намерений противника остаётся скрытой, поэтому успех зависит не только от расчёта, но и от чтения ситуации.

    Flame Steel: Mars Miners поддерживает сетевую игру, что делает каждую партию уникальной — стратегии эволюционируют, а мета формируется прямо сейчас. Игра находится на ранней стадии разработки, и это её сильная сторона: у игроков есть возможность первыми погрузиться в новый, нестандартный проект, повлиять на его развитие и открыть для себя механику, которая не копирует привычные шаблоны жанра.

    Если вам интересны тактические игры с глубиной, экспериментальным дизайном и упором на мышление, Flame Steel: Mars Miners заслуживает внимания уже сейчас.

    ПРАВИЛА ИГРЫ

    * Игровое поле состоит из клеток, на которых игроки поочерёдно размещают свои объекты. В каждом ходе игрок может выполнить одно строительное действие.

    * Строить разрешено только два типа объектов: станции-узлы и шахты. Любое строительство возможно исключительно на одну свободную клетку, расположенную рядом с уже существующим узлом игрока по вертикали или горизонтали. Диагональное размещение не допускается.

    * Станции-узлы формируют основу контроля территории и служат точками расширения. Шахты размещаются по тем же правилам, но учитываются как ресурсные объекты и напрямую влияют на итоговый результат партии.

    * Если игрок выстраивает непрерывную линию своих станций-узлов по вертикали или горизонтали, такая линия автоматически превращается в орудие. Орудие даёт возможность атаковать противника и разрушать его инфраструктуру.

    * Для выстрела из орудия игрок выбирает одну клетку, принадлежащую своему орудию, и указывает любую станцию-узел противника на поле. Выбранная вражеская станция-узел уничтожается и удаляется с игрового поля. Шахты напрямую атаковать нельзя — только через разрушение узлов, которые обеспечивают к ним доступ.

    * Игра продолжается до наступления установленного конца партии. Победителем становится игрок, который к этому моменту имеет наибольшее количество шахт-ресурсов на игровом поле. В случае равенства решающим фактором может служить контроль территории или дополнительные условия, определяемые режимом игры.

    https://mediumdemens.vps.webdock.cloud/mars-miners

    Antigravity

    За пару дней с помощью Antigravity перенес бэк Масоны-ДР (Masonry-AR) с PHP + MySQL на Node.js + MongoDB + Redis -> Docker. Возможности ИИ действительно поражают, помню как в 2022 году через ChatGPT писал простейшие шейдеры на shadertoy.com и казалось что эта игрушка больше ничего не сможет выше.
    https://www.shadertoy.com/view/cs2SWm

    Спустя четыре года я смотрю как оно в ~10 промптов играючи перекинула мой проект с одной бэк платформы на другую, добавив контейнеризацию.
    https://mediumdemens.vps.webdock.cloud/masonry-ar/

    Круто, действительно круто.

    Kaban Board

    KabanBoard — это open-source веб-приложение для управления задачами в формате Kanban. Проект ориентирован на простоту, понятную архитектуру и возможность доработки под конкретные задачи команды или отдельного разработчика.

    Решение подойдёт для небольших проектов, внутренних командных процессов или в качестве основы для собственного продукта без привязки к сторонним SaaS-сервисам.

    Репозиторий проекта доступен на GitHub:
    https://github.com/demensdeum/KabanBoard

    Основные возможности

    KabanBoard реализует базовый и практичный набор функций для работы с Kanban-досками.

    • Создание нескольких досок для разных проектов
    • Колоночная структура со статусами задач
    • Карточки задач с возможностью редактирования и удаления
    • Перемещение задач между колонками (drag & drop)
    • Цветовая маркировка карточек
    • Тёмная тема интерфейса

    Функциональность не перегружена и ориентирована на повседневную работу с задачами.

    Используемые технологии

    Проект построен на распространённом и понятном стеке.

    • Frontend: Vue 3, Vite
    • Backend: Node.js, Express
    • Хранилище данных: MongoDB

    Клиентская и серверная части разделены, что упрощает поддержку и дальнейшее развитие проекта.

    Развёртывание проекта

    Для локального запуска потребуется стандартное окружение.

    • Node.js
    • MongoDB (локально или через облачный сервис)

    Проект можно запускать как в обычном режиме через npm, так и с использованием Docker, что удобно для быстрого развёртывания в тестовой или внутренней среде.

    Практическое применение

    KabanBoard может использоваться в разных сценариях.

    • Внутренний инструмент для управления задачами
    • Основа для кастомного Kanban-решения
    • Учебный проект для изучения SPA-архитектуры
    • Стартовая точка для pet-проекта или портфолио

    Заключение

    KabanBoard — это аккуратное и практичное решение для работы с Kanban-досками. Проект не претендует на замену крупных корпоративных систем, но хорошо подходит для небольших команд, индивидуального использования и дальнейшего развития под конкретные задачи.

    Gofis

    Gofis — это лёгковесный инструмент командной строки для быстрого поиска файлов в файловой системе.
    Он написан на языке Go и активно использует параллелизм (goroutines), что делает его особенно эффективным
    при работе с большими директориями и проектами.

    Проект доступен на GitHub:
    https://github.com/demensdeum/gofis

    🧠 Что такое Gofis

    Gofis — это CLI-утилита для поиска файлов по имени, расширению или регулярному выражению.
    В отличие от классических инструментов вроде find, gofis изначально проектировался
    с упором на скорость, читаемый вывод и параллельную обработку каталогов.

    Проект распространяется под лицензией MIT и может свободно использоваться
    в личных и коммерческих целях.

    ⚙️ Ключевые возможности

    • Параллельный обход директорий с помощью goroutines
    • Поиск по имени файла и регулярным выражениям
    • Фильтрация по расширениям
    • Игнорирование тяжёлых директорий (.git, node_modules, vendor)
    • Человекочитаемый вывод размеров файлов
    • Минимальные зависимости и быстрая сборка

    🚀 Установка

    Для работы требуется установленный Go.

    git clone https://github.com/demensdeum/gofis
    cd gofis
    go build -o gofis main.go
    

    После сборки бинарный файл можно использовать напрямую.

    Также на странице релизов есть автономная версия для современных версий Windows:
    https://github.com/demensdeum/gofis/releases/

    🔍 Примеры использования

    Поиск файлов по имени:

    ./gofis -n "config" -e ".yaml" -p ./src
    

    Быстрый позиционный поиск:

    ./gofis "main" "./projects" 50
    

    Поиск с использованием регулярного выражения:

    ./gofis "^.*\.ini$" "/"
    

    🧩 Как это работает

    В основе gofis лежит конкурентная модель Go:

    • Каждая директория обрабатывается в отдельной goroutine
    • Используется семафор для ограничения количества активных задач
    • Каналы применяются для передачи результатов поиска

    Такой подход позволяет эффективно использовать ресурсы CPU
    и значительно ускоряет поиск на больших файловых деревьях.

    👨‍💻 Кому подойдёт Gofis

    • Разработчикам, работающим с крупными репозиториями
    • DevOps и системным администраторам
    • Пользователям, которым нужен быстрый поиск из терминала
    • Тем, кто изучает практическое применение concurrency в Go

    📌 Заключение

    Gofis — это простой, но эффективный инструмент, который делает одну задачу и делает её хорошо.
    Если вы часто ищете файлы в больших проектах и цените скорость,
    этот CLI-инструмент определённо заслуживает внимания.

    ollama-call

    Если вы используете Ollama и не хотите каждый раз писать собственную обвязку вокруг API,
    проект ollama_call заметно упрощает работу.

    Это небольшая Python-библиотека, которая позволяет отправить запрос к локальной LLM одной функцией
    и сразу получить ответ, в том числе в JSON-формате.

    Установка

    pip install ollama-call
    

    Зачем он нужен

    • минимальный код для работы с моделью;
    • структурированный JSON-ответ для дальнейшей обработки;
    • удобен для быстрых прототипов и MVP;
    • поддерживает потоковый вывод при необходимости.

    Пример использования

    from ollama_call import ollama_call
    
    response = ollama_call(
        user_prompt="Hello, how are you?",
        format="json",
        model="gemma3:12b"
    )
    
    print(response)
    

    Когда особенно полезен

    • вы пишете скрипты или сервисы поверх Ollama;
    • нужен предсказуемый формат ответа;
    • нет желания подключать тяжёлые фреймворки.

    Итог

    ollama_call — лёгкая и понятная обёртка для работы с Ollama из Python.
    Хороший выбор, если важны простота и быстрый результат.

    GitHub
    https://github.com/demensdeum/ollama_call

    SFAP: модульный фреймворк для современного сбора и обработки данных

    В условиях активного развития автоматизации и искусственного интеллекта задача эффективного сбора,
    очистки и преобразования данных становится критически важной. Большинство решений закрывают лишь
    отдельные этапы этого процесса, требуя сложной интеграции и поддержки.

    SFAP (Seek · Filter · Adapt · Publish) — это open-source проект на Python,
    который предлагает целостный и расширяемый подход к обработке данных на всех этапах их жизненного цикла:
    от поиска источников до публикации готового результата.

    Что такое SFAP

    SFAP — это асинхронный фреймворк, построенный вокруг четкой концепции пайплайна обработки данных.
    Каждый этап логически отделён и может независимо расширяться или заменяться.

    Проект основан на архитектурном паттерне Chain of Responsibility, что обеспечивает:

    • гибкость конфигурации пайплайна;
    • простое тестирование отдельных этапов;
    • масштабируемость под высокие нагрузки;
    • чистое разделение ответственности между компонентами.

    Основные этапы пайплайна

    Seek — поиск данных

    На этом этапе происходит обнаружение источников данных: веб-страниц, API, файловых хранилищ
    или других потоков информации. SFAP позволяет легко подключать новые источники без изменения
    остальной системы.

    Filter — фильтрация

    Фильтрация предназначена для удаления шума: нерелевантного контента, дубликатов, технических элементов
    и данных низкого качества. Это критически важно для последующих этапов обработки.

    Adapt — адаптация и обработка

    Этап адаптации отвечает за преобразование данных: нормализацию, структурирование,
    семантическую обработку и интеграцию с ИИ-моделями (в том числе генеративными).

    Publish — публикация

    На финальном этапе данные публикуются в целевом формате: базы данных, API, файлы, внешние сервисы
    или контент-платформы. SFAP не ограничивает способ доставки результата.

    Ключевые особенности проекта

    • Асинхронная архитектура на базе asyncio
    • Модульность и расширяемость
    • Поддержка сложных пайплайнов обработки
    • Готовность к интеграции с AI/LLM-решениями
    • Подходит для высоконагруженных систем

    Практические сценарии использования

    • Агрегация и анализ новостных источников
    • Подготовка датасетов для машинного обучения
    • Автоматизированный контент-пайплайн
    • Очистка и нормализация больших потоков данных
    • Интеграция данных из разнородных источников

    Начало работы с SFAP

    Для старта достаточно:

    1. Клонировать репозиторий проекта;
    2. Установить зависимости Python;
    3. Определить собственные шаги пайплайна;
    4. Запустить асинхронный процесс обработки данных.

    Проект легко адаптируется под конкретные бизнес-задачи и может расти вместе с системой,
    не превращаясь в монолит.

    Заключение

    SFAP — это не просто парсер или сборщик данных, а полноценный фреймворк для построения
    современных data-pipeline-систем. Он подойдёт разработчикам и командам, которым важны
    масштабируемость, архитектурная чистота и готовность к работе с интеллектуальной обработкой данных.
    Исходный код проекта доступен на GitHub:
    https://github.com/demensdeum/SFAP

    FlutDataStream

    Приложение Flutter, преобразующее любой файл в последовательность машиночитаемых кодов (QR и DataMatrix) для высокоскоростной потоковой передачи данных между устройствами.

    Особенности
    * Двойное кодирование: Представляет каждый блок данных одновременно как QR-код и код DataMatrix.
    * Высокоскоростная потоковая передача: Поддерживает автоматический интервал переключения до 330 мс.
    * Интеллектуальное разбиение на фрагменты: Автоматически разбивает файлы на настраиваемые фрагменты (по умолчанию: 512 байт).
    * Подробный сканер: Чтение ASCII-кода в реальном времени для отладки и мгновенной обратной связи.
    * Автоматическое восстановление: Мгновенно восстанавливает и сохраняет файлы в каталог загрузок.
    * Системная интеграция: Автоматически открывает сохраненный файл с помощью системного приложения по умолчанию после завершения.

    https://github.com/demensdeum/FlutDataStream

    Почему никак не получается исправить баг?

    Вы часами сидите над кодом, перебираете гипотезы, правите условия, но баг все равно воспроизводится. Знакомо? Это состояние фрустрации часто называют «охотой на призраков». Кажется, что программа живет своей жизнью, игнорируя ваши исправления.

    Одной из самых частых — и самых обидных — причин такой ситуации является поиск ошибки совершенно не в том месте приложения.

    Ловушка «ложных симптомов»

    Когда мы видим ошибку, наше внимание приковано к месту, где она «выстрелила». Но в сложных системах место проявления бага (crash или некорректное значение) — это лишь финал длинной цепочки событий. Пытаясь починить финал, вы боретесь с симптомами, а не с болезнью.

    Именно здесь на помощь приходит концепция блок-схемы.

    Как это работает в реальности

    Конечно, прямо составлять (рисовать) блок-схему на бумаге каждый раз не обязательно, но важно иметь её в голове или под рукой как архитектурный ориентир. Блок-схема позволяет визуализировать работу приложения как дерево исходов.

    Без понимания этой структуры разработчик часто блуждает в темноте. Представьте ситуацию: вы правите логику в одной ветви условий, в то время как приложение (из-за определенного набора параметров) уходит в совершенно другую ветку, о которой вы даже не задумывались.

    Результат: Вы тратите часы на «идеальное» исправление кода в одной части алгоритма, что, естественно, никак не исправляет проблему в другой его части, где на самом деле происходит сбой.


    Алгоритм победы над багом

    Чтобы перестать биться в закрытую дверь, нужно изменить подход к диагностике:

    • Найдите состояние в дереве исходов: Прежде чем писать код, нужно точно определить путь, по которому прошло приложение. В какой точке логика свернула не туда? Какое именно состояние (State) привело к проблеме?
    • Воспроизведение — это 80% успеха: Обычно это делается силами тестировщиков и автотестов. Если баг «плавающий», к процессу подключается разработка для совместного поиска условий.
    • Используйте максимум информации: Для локализации важны логи, версия ОС, параметры устройства, тип подключения (Wi-Fi/5G) и даже конкретный оператор связи.

    «Фотография» момента ошибки

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

    Совет на будущее: Если вы столкнулись со сложным кейсом, добавьте в этот участок кода расширенную отладочную информацию (debug logging) на случай, если ситуация повторится.


    Проблема «неуловимых» состояний в эпоху AI

    В современных системах, использующих LLM (Large Language Models), классический детерминизм («один вход — один выход») часто нарушается. Вы можете передать абсолютно те же входные данные, но получить другой результат.

    Это происходит из-за недетерминированности современных продакшн-систем:

    • Параллелизм на GPU: Операции с плавающей запятой в GPU не всегда ассоциативны. Из-за параллельного выполнения потоков порядок сложения чисел может незначительно меняться, что влияет на результат.
    • Температура GPU и троттлинг: Скорость выполнения и распределение нагрузки могут зависеть от физического состояния «железа». В огромных моделях эти микроскопические различия накапливаются и могут привести к выбору другого токена на выходе.
    • Динамический батчинг: В облаке ваш запрос объединяется с другими. Разный размер пакета (batch size) меняет математику вычислений в ядрах.

    В таких условиях воспроизвести «то самое состояние» становится практически невозможно. Здесь спасает только статистический подход к тестированию.


    Когда логика бессильна: Проблемы с памятью

    Если вы работаете с «unsafe» языками (C или C++), баг может возникать из-за разрушения памяти (Memory Corruption).

    Это самые тяжелые случаи: ошибка в одном модуле может «затереть» данные в другом. Это приводит к совершенно необъяснимым и единичным сбоям, которые невозможно отследить по обычной логике приложения.

    Как защититься на уровне архитектуры?

    Чтобы избежать таких «мистических» багов, стоит использовать современные подходы:

    • Паттерны многопоточного программирования: Четкая синхронизация исключает состояние гонки (race conditions).
    • Языки с безопасной многопоточностью: Инструменты, гарантирующие безопасность памяти еще на этапе компиляции:
      • Rust: Система владения (Ownership) исключает ошибки памяти.
      • Swift 6 Concurrency: Строгие проверки изоляции данных.
      • Erlang: Полная изоляция процессов через модель акторов.

    Резюме

    Исправление бага — это не про написание нового кода, а про понимание того, как работает старый. Помните: вы можете тратить время на правку ветки, в которую управление даже не заходит. Фиксируйте состояние системы, учитывайте фактор AI-недетерминированности и выбирайте безопасные инструменты.

    Ferral

    Ferral — это высокоуровневый многопарадигмальный язык программирования, специально разработанный для генерации кода на основе больших языковых моделей (LLM). В то время как традиционные языки разрабатывались с учетом эргономики человека, Ferral оптимизирован для того, как большие языковые модели (LLM) рассуждают, токенизируют и выводят логику.

    Название пишется с двумя буквами «R», что указывает на «переработанный» подход к непредсказуемой природе кода, генерируемого искусственным интеллектом.

    https://github.com/demensdeum/ferral

    DoryChat

    DoryChat — это безопасная платформа для обмена мгновенными сообщениями с временным хранением данных, построенная на архитектурной модели с нулевым сохранением данных. Сообщения являются временными, зашифрованы сквозным шифрованием и автоматически удаляются через 60 секунд, гарантируя, что разговоры не оставляют следов в центральной инфраструктуре.

    https://github.com/demensdeum/DoryChat
    https://mediumdemens.vps.webdock.cloud/dorychat-app

    Noski – SOCKS5 Proxy Server in Rust

    Noski — это облегчённая асинхронная реализация SOCKS5-прокси-сервера, написанная на Rust. Она построена с использованием среды выполнения Tokio для высокопроизводительного неблокирующего ввода-вывода. Также существуют механизмы обхода DPI и шифрование с помощью клиента Noski под названием Pyatki.

    https://github.com/demensdeum/Noski