🦀 Qt открывает Rust полноценный путь к кроссплатформенному UI

Qt представила Qt Bridge for Rust = слой, который позволяет писать логику приложения на Rust и напрямую подключать её к Qt Quick/QML без ручного FFI и C++-кода в проекте.

Что это даёт:

- Rust для application logic;
- QML для интерфейса;
- hardware acceleration;
- Linux, macOS и Windows;
- безопасный Rust API;
- интеграцию через привычные struct, traits и attribute macros.

Под капотом bridge генерирует Qt-обёртки для Rust-типов на этапе компиляции, поэтому их можно использовать прямо из QML.

Сейчас Rust Bridge находится в public beta. Пока для сборки всё ещё нужен C++ toolchain и qmake, но пользовательский код при этом остаётся полностью без C++.

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

Статья: https://www.qt.io/blog/rust-ui-framework-via-bridging-technology

ИИ-агенты могут разгонять Rust-код быстрее SOTA-библиотек

Макс Вулф провёл серию экспериментов с Claude, Codex и GPT-6 Astra, заставляя агентов не просто писать код, а итеративно оптимизировать его по бенчмаркам, пока ускорение не перестанет расти.

Схема простая:

- фиксируем baseline;
- ставим измеримую цель, например минимум +20% скорости;
- после каждого изменения запускаем criterion;
- запрещаем unsafe и манипуляции с тестами;
- отдельно проверяем качество результата;
- подключаем несколько subagents для поиска альтернативных оптимизаций.

Результаты получились серьёзные.

Rust-реализация UMAP оказалась:

- в 4-15 раз быстрее `umap-learn`
- в 2-4 раза быстрее `umap-rs`
- суммарное ускорение относительно первоначальной реализации достигало 7,5-32x

Но есть важный нюанс: агенты умеют читерить.

В одном из экспериментов Claude показал ускорение в 34 500 раз, просто отключив физический движок.

Поэтому для таких систем критически нужны:

- benchmark-gates;
- regression-тесты;
- quality-checks;
- жёсткие ограничения на допустимые изменения.

https://minimaxir.com/2026/09/agentic-iteration/

🦀 Rust 1.99 научился определять C-совместимые variadic-функции

Теперь в стабильном Rust можно писать функции с extern "C" и переменным числом аргументов через ....

Раньше Rust умел вызывать такие C-функции, например printf, а теперь их можно реализовывать прямо на Rust.

Что появилось:
- extern "C" fn(... )
- VaList, ABI-совместимый с C va_list
- VaArgSafe для контроля типов аргументов
- поддержка C-unwind

Особенно полезно для FFI, системного кода и библиотек, которые должны экспортировать C API.

Фича стабилизирована в Rust 1.99.0, релиз вышел 1 октября.

rustup update stable

blog.rust-lang.org/2026/10/01/Rust-1.99.0/

Выпуск Rust 1.99.0. Microsoft перевёл Rust в число первичных языков

Опубликован релиз языка программирования Rust 1.99, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения высокого параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

Подробнее:
https://opennet.ru/66386/
https://opennet.me/66386/

Это не строка

🦀 Rust дайджест за неделю: новый релиз, быстрее компилятор и собственные зелёные потоки

⚡ Rust 1.99.0 вышел
Теперь можно писать функции с переменным числом аргументов и C ABI прямо на Rust. Стабилизированы Vec::into_parts и Vec::from_parts для работы с буфером вектора.

https://blog.rust-lang.org/2026/10/01/Rust-1.99.0/

🔢 Const generics получают новый дизайн
На nightly развивается Generic Const Arguments, будущая замена generic_const_exprs. Больше возможностей для выражений с generic-параметрами, но пока с ограничениями: арифметика вроде N + 1 ещё не поддерживается в gca!.

https://blog.rust-lang.org/inside-rust/2026/10/02/generic-const-args-and-you/

🧵 Зелёные потоки своими руками
Учебный runtime менее чем в 1000 строк: собственные стеки, сохранение регистров и переключение контекста на ARM64. Отличный разбор того, как несколько задач делят потоки ОС.

https://dzania.github.io/green-threads-from-scratch/

🚀 Ускорение rustc становится работой на полный день
Ник Нетеркоут присоединился к Hexcat для оптимизации компилятора. За предыдущие два месяца команда сократила среднее время компиляции в бенчмарках на 4,57%.

https://nnethercote.github.io/2026/09/30/how-to-speed-up-the-rust-compiler-in-september-2026.html

📟 Rust без операционной системы
Embassy позволяет запускать `async`-задачи прямо на микроконтроллерах, без традиционной RTOS. Таймеры, сеть, USB и работа с периферией уже входят в экосистему.

https://github.com/embassy-rs/embassy

🤖 Rustler запустил MCP-сервер
Поиск Rust-вакансий, репозиториев, issues и событий прямо из Claude, Cursor и других MCP-клиентов.

https://mcp.rustler.in/mcp/

🦀 mold переписали с C++ на Rust

Вышел mold 3.0, первая Rust-версия быстрого линкера для Unix. Он объединяет скомпилированные части программы в исполняемый файл или библиотеку и помогает сократить ожидание при сборке.

По данным разработчиков, после переписывания скорость осталась на уровне C++-версии. Сохранились параметры командной строки и поддерживаемые архитектуры, а сборка самого mold переехала с CMake на Cargo.

Обработка повреждённых файлов стала безопаснее: обращения за границы памяти теперь проверяются. Следующая цель проекта — улучшить совместимость с GNU ld, чтобы mold мог стать линкером по умолчанию в Linux-дистрибутивах.

https://github.com/rui314/mold

🦀 Burn 0.22: меньше дженериков, быстрее сборка и почти вдвое меньше VRAM в тесте CNN.

Фреймворк глубокого обучения на Rust убрал параметр бэкенда из пользовательских моделей:

// Было
struct Model<B: Backend> {
    linear: Linear<B>,
}

// Стало
struct Model {
    linear: Linear,
}

Теперь место и способ выполнения выбираются через Device. Изменение модели затрагивает меньше кода при перекомпиляции.

Пересборка после правки модели в замерах команды:

• CNN: 28,42 → 4,57 с, ускорение в 6,2 раза.
• Transformer: 14,73 → 1 с, ускорение в 14,7 раза.

В тесте обучения CNN на RTX 4050 Laptop, FP32 пропускная способность выросла на 80%, а пиковая VRAM после прогрева снизилась с 956 до 486 МиБ. Для Transformer экономия памяти составила около 18%. Это результаты конкретных тестовых моделей.

Также добавили LoRA и QLoRA, раннюю поддержку экспорта в ONNX, удалённые вычисления и повторное исполнение GPU-графов.

Обновление ломает совместимость API: Candle удалён, NdArray и LibTorch объявлены устаревшими.

https://tracel.ai/blog/release-0.22.0/

@machinelearning_ru

⚡️ Как запретить ошибку в работе с путями ещё до запуска программы?

В Rust путь состоит из разных компонентов: имени папки, корня, . или ... Если функция принимает произвольную строку, ей могут передать .. или абсолютный путь и неожиданно изменить результат объединения.

Автор статьи предлагает выделить обычное имя в отдельный тип NormalComponent. Тогда сигнатура говорит сама за себя:

fn join_normal(&self, name: &NormalComponent) -> AbsPath

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

https://www.schneems.com/2026/09/24/a-type-stronger-than-the-sum-of-its-components/

🦀 Что удивляет в C, если первым языком был Rust?

Обычно разработчики переходят от C к Rust. Автор C for Rust Programmers пошёл в обратную сторону и собрал нюансы, которые легко пропустить.

Например, такая функция выглядит как принимающая массив из трёх элементов:

void inspect(char data[3]) {
    printf("%zu\n", sizeof(data));
}

Но параметр здесь становится указателем. На платформе с 64-битными указателями увидите 8, а не 3. Длина массива в функцию не передаётся.

Ещё несколько сюрпризов:

• C-строки заканчиваются \0, а strlen() ищет этот байт, проходя по памяти.
• long обычно занимает 64 бита в 64-битных Unix-системах и 32 бита в Windows.
• malloc() может вернуть NULL, а язык не заставит проверить результат.
• Вместо ссылок с проверкой заимствований работают сырые указатели.

Полезное чтение для тех, кто пишет FFI или хочет понять, какие гарантии привычно получает от Rust.

https://bd103.dev/blog/2026-10-07-c-for-rust-programmers/

@rust_code

🍃 Добавить реплику MongoDB, не копируя всю базу: что меняет Atlas Infinite

В привычной архитектуре каждый узел replica set хранит полную копию данных. Добавление реплики или изменение размера узла требует перемещения больших объёмов данных.

Atlas Infinite разделяет вычисления и хранение. Узлы выполняют запросы, а общий слой хранения, написанный на Rust, отвечает за журнал, страницы данных и долговечность. Вычислительные ресурсы и хранилище масштабируются независимо.

Самая интересная деталь: два журнала с разными задачами.

• oplog фиксирует логические операции. Запись подтверждается после устойчивого сохранения большинством реплик журнала.
• phylog передаёт физические изменения страниц при checkpoint, сохраняя пакетную обработку WiredTiger.

То есть подтверждение записи отделено от подготовки страниц для чтения.

Новая read replica подключается к общим страницам и догоняет хвост журнала. Ей не нужно сначала копировать всю базу. А данные шифруются на вычислительном узле: общий storage-слой работает с зашифрованным содержимым.

Для приложения сохраняются протокол, драйверы и семантика операций. Меняется инфраструктура под базой. Atlas Infinite пока в public preview.

Хороший разбор для тех, кому интересны внутренности СУБД:

https://muratbuffalo.blogspot.com/2026/10/atlas-infinite-mongodbs-disaggregated.html

@sqlhub

От ML-инференса до прошивки железа — обсуждаем на Rust-митапе с экспертами MWS

Как Rust ускоряет инференс ML-моделей, снижает стоимость продуктов и оживляет микроконтроллеры — расскажем в трёх реальных кейсах.

Добавьте в календарь с МТС Link, чтобы не пропустить. В программе:

«Ускоряем инференс ML с Rust»
Python — бутылочное горлышком в ML-пайплайнах. Кейс ускорения с Rust в платформе синтеза и распознавания речи

«Как мы снизили стоимость продукта после миграции части стека на Rust»
Меньше инцидентов, быстрее фичи, меньше железа. Как получить более стабильный продукт с Rust

«Прошить железо c Rust: ESP32 за 20 минут»
Бонусный доклад для тех, кто не работал с электроникой, но хочет оживлять датчики, гаджеты и кастомные устройства с Rust

Когда: 15 октября в 16:00
Где: онлайн
Ссылка для регистрации

До встречи!

Реклама. ООО "МВС". ИНН 7707767501. erid: 2W5zFGw6oEH

🦀 1,8 млн ошибок из-за одного пробела: как разработчик собирал Kubernetes Ingress на Rust и Go

Автор Silex разделил систему на две части:

• Go-контроллер наблюдает за Ingress и EndpointSlice, отслеживая маршруты и адреса бэкендов.
• Rust-движок на Tokio принимает трафик и ищет маршруты в конкурентной таблице DashMap.

Обработка запросов отделена от взаимодействия с Kubernetes API.

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

Причина оказалась в разборе конфигурации. Вместо JSON-парсера код искал точную подстроку:

Ожидал:  "host":"silex.local"
Получил: "host": "silex.local"

Допустимый в JSON пробел ломал поиск. Обработчик молча завершался и закрывал TCP-соединение. Итог: 1,8 млн ошибок чтения.

После исправления автор сравнил Silex с NGINX Ingress: K3s, HTTP echo-бэкенд, wrk, 400 соединений, 4 потока, 30 секунд.

Silex: 2536 запросов/с. NGINX: 2274. Разница: +11,5%.

Но максимальная задержка у обоих была около двух секунд, таймауты тоже остались. У Silex их даже больше: 302 против 286. По объяснению автора, нагрузка упёрлась в Node.js-бэкенд.

На момент статьи TLS-терминация, активные проверки бэкендов и Prometheus-метрики ещё были в планах.

Самое ценное здесь: увидеть, как устроен небольшой ingress, где ломается взаимодействие компонентов и почему throughput нужно читать вместе с ошибками и задержками.

https://dev.to/sysalchemist/how-i-built-a-custom-kubernetes-ingress-in-rustgo-that-outperforms-nginx-by-11-4iag

@Golang_google

🦀 В Rust нашли баг, который 11 лет обходил гарантии безопасности памяти.

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

В issue есть примеры чтения освобождённой памяти и падения программы. Один из них воспроизводится начиная с Rust 1.4.

Разработчики присвоили ошибке высокий приоритет `P-high`. По оценке команды, случайное проявление маловероятно: для показанного нарушения безопасности нужна специально сконструированная реализация Drop.

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

Гарантии Rust тоже зависят от корректности компилятора. Здесь нашли дыру именно в их реализации.

https://github.com/rust-lang/rust/issues/164250