Rust

👣 В Rust появился интересный подход к обработке ошибок - `eros`. Обычно выбор такой: anyhow — удобно, но теряется точная типизация ошибок. thiserror — типобезопасно, но приходится писать enum и boilerplate. eros пытается взять лучшее из обоих миров: typed error unions без ручного объявления enum. Пример:

fn read() -> Result<String, ErrorUnion<(IoError, RecvError)>> {
    // ...
}

Что это даёт: • сохраняется полная информация о типах ошибок • ошибки естественно композятся при вызове функций • не нужно писать отдельные enum под каждый слой • можно добавлять context по цепочке вызовов • есть backtraces и интеграция с логированием • zero-cost, когда ошибки не происходит По сути, это попытка сделать error handling в Rust более удобным, не жертвуя строгой типизацией. 212 звёзд, свежий релиз v0.6.0, проект активно поддерживается. GitHub: http://github.com/mcmah309/eros

Rust теперь можно компилировать в JVM bytecode. rustc_codegen_jvm - экспериментальный backend для компилятора Rust, который берёт Rust MIR и превращает его в .class файлы, а затем собирает runnable .jar под JVM 8+. Что уже заявлено: - генерация исполняемого .jar - поддержка базового core - if/else, match, for, while, loop - structs, tuples, arrays, slices, enums - traits, closures, dynamic dispatch - function pointers, recursion, generics - часть unsafe, включая unions - оптимизации вроде constant folding, propagation и dead code elimination Пайплайн выглядит так: Rust frontend → MIR → OOMIR → JVM classfile → R8 → .jar https://github.com/IntegralPilot/rustc_codegen_jvm

🔥 Продвинутый Rust без учебных игрушек Базу уже прошли? Тогда следующий шаг - production-разработка. На Stepik идет скидка 60% на продвинутый курс по Rust для тех, кто хочет не просто знать синтаксис, а строить реальные системы. Внутри: async, unsafe, gRPC, lock-free, observability, Kafka, NATS, axum, tower, CI/CD и канареечный деплой. Финальный проект - production-ready feed-сервис от архитектуры до релиза. 21 модуль, 84 урока, 400+ проверочных шагов. Если хотите перейти от маленьких Rust-утилит к коммерческой разработке, сейчас хороший момент зайти: https://stepik.org/a/285608/pay

Как на самом деле работает .await: пишем свой async-рантайм на Rust с нуля Если попросить среднего Rust-разработчика объяснить, что делает .await, в ответ обычно звучит что-то про «приостанавливает выполнение, пока не придут данные». Это верно ровно настолько же, насколько «компьютер думает» объясняет работу процессора. На самом деле за .await не стоит ни потока, ни приостановки в привычном смысле. Стоит обычный enum и вызов функции по указателю. Я полгода писал async-код на tokio, искренне считая рантайм чернм ящиком, в который лучше не лезть. Сломался этот настрой в тот день, когда у меня в проде намертво зависла одна задача: по логам она обязана была проснуться, но не просыпалась. Я потерял на ней вечер, а причина оказалась в одной строчке про Waker, к которой мы ещё вернёмся. Тогда я плюнул и за пару вечеров написал свой рантайм с нуля - и оказалось, что весь фундамент умещается в голове за один присест и примерно в 200 строк кода. После этого и тот баг стал очевидным, и исходники tokio начали читаться как книга, а не как заклинание. https://habr.com/ru/articles/1050160/

✔️ OpenAI стала платиновым участником Rust Foundation Компания Сэма Альтмана выделит $600 000 на развитие языка.  Средства, идущие сверх ежегодного членского взноса, направят на поддержку целей проекта Rust, инновационной лаборатории, а также на прямое финансирование разработчиков открытого ПО. Интересы OpenAI в совете директоров фонда будет представлять Предраг Груевски, технический специалист OpenAI и разработчик инструмента проверки совместимости версий cargo-semver-checks. За 2 дня до официального вступления в фонд OpenAI распределила $160 000 через GitHub Sponsors. Целевые гранты получили разработчики открытых проектов, от которых зависят Astral и Codex. @ai_machinelearning_big_data #news #ai #ml

В Rust нашли смешной и неприятный кейс: несколько символов @ могут заставить rustc жрать десятки гигабайт памяти. Автор копался в macro expansion и заметил, что парсер declarative macros в rustc ведёт себя как упрощённый Earley parser: он одновременно держит несколько возможных вариантов разбора макроса. Обычно это нормально. Но если сделать макрос с вложенными повторениями, количество промежуточных вариантов начинает резко расти. Формально ожидался кубический рост, но в тесте всё выглядело ещё хуже. Результат: - валидный Rust-код - всего несколько десятков токенов @ - компиляция на n = 41 заняла около 80 секунд - пиковая память дошла до 44 ГБ Самое интересное: код не использует сложные выражения, типы или гигантские зависимости. Только macro_rules и фиксированные токены. Главная мысль не в том, что «Rust сломан». Главная мысль в другом: макросы в Rust - это почти отдельный язык внутри языка, и даже маленький паттерн может внезапно превратиться в тяжёлую задачу для компилятора. Автор предлагает смотреть в сторону packrat-подхода с memoization, где состояние парсинга можно кэшировать и гарантировать линейное число шагов по input.len() * arm.len(). Красивый пример того, как в системном языке проблемы иногда прячутся не в unsafe, не в borrow checker и не в LLVM. А в маленьком macro_rules, который выглядит безобидно. Хорошее чтиво на выходные 🦀 bal-e.org/blog/2026/oops-cubic-macro/

👣 Rust CLI, который проверяет, существует ли уже ваша идея. patent ищет совпадения сразу в 11 dev-реестрах: crates.io, npm, PyPI, GitHub, Docker Hub и других. После этого показывает, насколько ниша свободна: Open, Crowded или Saturated. Одна команда:

patent "interactive CLI to kill whatever's on a port"

Инструмент ранжирует результаты через локальный semantic search, затем делает AI-вердикт через Ollama. Всё работает локально: данные не уходят с вашей машины. Хороший способ сэкономить месяц перед очередным pet project и быстро понять, не сделали ли вашу идею уже десять раз. http://github.com/r14dd/patent

Исследователи NVIDIA перенесли модель владения Rust в GPU-kernels. Paper: “Fearless Concurrency on the GPU”. В нём представлен cuTile Rust. Проблема была в том, что при написании кастомных GPU-ядер на Rust разработчикам фактически приходилось выходить за пределы гарантий безопасности Rust. cuTile Rust пытается это исправить: * mutable outputs разбиваются на непересекающиеся части * запуск kernels сохраняет правила ownership от host до device * при необходимости остаются локальные opt-out механизмы для низкоуровневого контроля Производительность тоже держится на уровне: * 7 TB/s для element-wise операций на NVIDIA B200 * 2 PFlop/s для GEMM, это 96% от cuBLAS * результат сопоставим с cuTile Python в пределах погрешности измерений Авторы также собрали Grout, inference engine поверх cuTile Rust, и прогнали реальные модели: * 171 tokens/s для Qwen3-4B на RTX 5090 * 82 tokens/s для Qwen3-32B на B200 * конкурентный уровень рядом с vLLM и SGLang Итог - безопасный и идиоматичный Rust почти на полной CUDA-производительности. Для Rust в ML-инфраструктуре это большой шаг. http://arxiv.org/abs/2606.15991 #Rust #RustLang #GPU #CUDA #MachineLearning #SystemsProgramming #NVIDIA @data_analysis_ml

✔️ Фраза «у Rust тоже есть CVE» часто звучит как аргумент против memory safety. Но тут есть важная разница. В C, если вы вызвали функцию не так, например передали NULL туда, где библиотека этого не ждала, и получили segfault, это часто называют неправильным использованием API. То есть ответственность перекладывается на разработчика: сам виноват, надо было читать документацию. В Rust логика другая. Если функция помечена как safe, она не должна приводить к memory bugs. Даже если вы передали странные данные, даже если сценарий неидеальный. Safe Rust по контракту обязан оставаться memory-safe. Поэтому если safe-функция в Rust падает с segfault или приводит к проблеме памяти, это уже не «ты неправильно использовал API». Это баг библиотеки. И такой случай действительно может стать CVE. Сырые числа CVE у Rust и C/C++ нельзя сравнивать напрямую. В C/C++ огромный класс проблем считается нормальным риском неправильного использования. В Rust тот же класс проблем считается нарушением гарантий safe API. Именно поэтому CVE в Rust часто говорит не «Rust такой же небезопасный», а наоборот: экосистема строже относится к тому, что safe-код вообще не должен ломать память. Хороший разбор от Jakub Beránek из команды разрабов компилятора Rust: http://kobzol.github.io/rust/2026/06/15/how-memory-safety-cves-differ-between-rust-and-c-cpp.html #Rust #RustLang #MemorySafety #Security #CVE

Скотт Чакон, сооснователь GitHub, переписал Git на Rust. С помощью ИИ-агентов. Проект называется Grit. Это новая реализация Git с нуля: library-first, memory-safe и почти полностью на безопасном Rust. Она уже проходит 99,3% собственного тестового набора Git — 41 715 из 42 001 теста. Цифры: * 360 000+ строк Rust * 7 000+ коммитов * 500+ pull request’ов * около 45 млрд токенов через Claude, Cursor и Codex * примерно $10–15 тыс. затрат на ИИ Почему это важно: * library-first дизайн, без постоянного fork/exec для каждой Git-операции * reentrant, linkable, modular архитектура: Git можно напрямую встраивать в GitButler, Jujutsu, Zed и другие инструменты * потенциальная WASM-сборка: Git-команды можно запускать в edge functions * лицензия MIT вместо GPL * почти полностью safe Rust: только один FFI-модуль для date/time Отдельно интересен сам разбор разработки. Это честный взгляд на agentic coding в большом масштабе: агенты, которые «читерят» в тестах, тихо ломают код, создают проблемы с координацией и превращают Cursor в режим бесконечного гринда. Стоит прочитать: http://blog.gitbutler.com/true-grit #Rust #RustLang #Git #OpenSource #AIAgents #SystemsProgramming #DevTools

👣 Rust без боли начинается не с синтаксиса, а с правильных паттернов Microsoft выложила практический гайд Rust: Patterns & Engineering How-Tos - не для тех, кто только открыл println!, а для разработчиков, которые уже упёрлись в реальные production-вопросы. Что внутри: - type-state и newtype для безопасного дизайна API - PhantomData для lifetime branding, variance и zero-cost типизации - channels, actors и concurrency-паттерны - async pitfalls, где Rust чаще всего ломает ожидания новичков - error handling через thiserror и anyhow - тестирование через unit, integration, doc tests и proptest - benchmarking через criterion Это особенно полезно для тех, кто приходит из C++, C# или Go и внезапно понимает, что borrow checker - это не главный враг. Главная сложность в Rust - выбрать правильную форму абстракции до того, как код превратится в набор lifetime-костылей. Если вы уже прошли Rust Book, но всё ещё зависаете на generics, trait bounds, PhantomData, async и тестировании, это очень хороший следующий шаг. https://microsoft.github.io/RustTraining/rust-patterns-book/ #rust #rustlang

🔥 Продвинутый Rust без учебных игрушек Базу уже прошли? Тогда следующий шаг - production-разработка. На Stepik идет скидка 60% на продвинутый курс по Rust для тех, кто хочет не просто знать синтаксис, а строить реальные системы. Внутри: async, unsafe, gRPC, lock-free, observability, Kafka, NATS, axum, tower, CI/CD и канареечный деплой. Финальный проект - production-ready feed-сервис от архитектуры до релиза. 21 модуль, 84 урока, 400+ проверочных шагов. Если хотите перейти от маленьких Rust-утилит к коммерческой разработке, сейчас хороший момент зайти: https://stepik.org/a/285608/pay

Rust Project показал, как на самом деле выглядит поддержка большого языка, когда вокруг компилятора живут отдельные инструменты: Cargo, Clippy, rustfmt, rust-analyzer, Miri и другие. Проблема простая: эти проекты удобнее развивать в отдельных репозиториях, потому что у них свои команды, CI, ревью и процессы. Но при этом они должны регулярно синхронизироваться с rust-lang/rust, потому что nightly-сборки, rustup-компоненты и внутренние compiler API завязаны на центральный репозиторий. Обычные варианты плохо масштабируются: - monorepo даёт атомарные изменения, но делает вход в проект тяжелее и привязывает всех к процессам compiler team - git submodules простые, но ломают DX: забытые --recursive, грязные состояния, случайные изменения SHA и невозможность нормально менять родительский проект и инструмент в одном PR - git subtree лучше подходит для атомарных изменений, но на масштабе Rust стал слишком медленным, особенно для Miri, где синхронизация могла не завершаться часами Поэтому Rust использует Josh - инструмент на Rust для быстрых и обратимых фильтров поверх git-истории. В статье его по сути называют “git subtree on steroids”: тот же смысл bidirectional sync, но быстрее и с более чистой историей. Поверх Josh команда сделала josh-sync - небольшой Rust-инструмент, который унифицирует pull/push-синхронизацию между rust-lang/rust и дочерними проектами. Часть операций уже автоматизирована через GitHub Actions: CI может сам открыть PR на синхронизацию и сообщить в Zulip, если нужен ручной разбор конфликта. Сейчас Josh используют для Miri, Rust Analyzer, compiler-builtins, stdarch и Rust Compiler Development Guide. Clippy и часть других проектов ещё остаются на subtree, но план - постепенно мигрировать и их. Это пример инженерной инфраструктуры вокруг языка. Rust масштабируется не только через типы, borrow checker и compiler work, но и через скучную, сложную механику сопровождения десятков связанных репозиториев, где один breaking change во внутреннем API не должен случайно сломать nightly-инструменты. Josh здесь закрывает именно эту боль: сохранить независимость репозиториев, но при этом дать возможность синхронно менять компилятор и завязанные на него инструменты без адского ручного sync-процесса. https://blog.rust-lang.org/inside-rust/2026/06/04/how-josh-helps-rust-manage-code-across-multiple-repositories/

✔️ ChatGPT получил динамическое обновление контекста OpenAI начала развертывание автоматической фоновой памяти для ChatGPT в США на тарифах Plus и Pro. В основе системы лежит механизм фоновой организации данных Dreaming. Модель самостоятельно извлекает контекст, детали рабочих проектов и предпочтения из множества сессий без прямых команд на запоминание. Главное отличие новой архитектуры - динамическое обновление фактов. Алгоритм актуализирует информацию со временем, понижая значимость устаревших данных. Прежняя реализация памяти полагалась на статичные факты, требовавшие ручного управления. В ближайшие недели OpenAI расширит географию доступа и откроет функцию для пользователей бесплатных аккаунтов. openai.com ✔️ xAI открыла API модели Grok Imagine Video 1.5 Компания выпустила превью-версию модели Grok Imagine Video 1.5 для генерации 720p-видео по картинке. Релиз позиционируется как конкурент Seedance и Google Veo. Модель анимирует изображение по текстовым промптам: задается направление движения камеры, динамика и атмосфера сцены. Алгоритм сохраняет оригинальную детализацию и схему освещения исходника. Также поддерживается склейка нескольких планов в длинные ролики с сохранением визуальной консистентности. Доступ к новинке открыт через API. x.ai ✔️ Nvidia купила ИИ-стартап Kumo Сделка оценивается в 400 млн долларов. Наработки Kumo интегрируют в платформу Nvidia AI Foundry, где корпоративные клиенты смогут обучать кастомные модели на внутренних реляционных базах. Стек Kumo адаптирован для анализа сложных структур из множества связанных таблиц, которые тяжело обрабатывать классическими LLM. Алгоритмы комбинируют графовое машинное обучение и генерацию синтетических данных. Платформа решает задачи предиктивной аналитики: от прогнозирования оттока пользователей до оценки вероятности финансовых дефолтов. В рамках сделки в Nvidia перейдет команда стартапа. Среди действующих клиентов Kumo - DoorDash, Reddit, Databricks и Snowflake. Актуальная модель стартапа вышла в апреле этого года. theinformation.com ✔️ Релиз Reve 2.0: генерация 4K-изображений через редактируемые макеты Reve представила новый генератор картинок на архитектуре Large Layout Model. Система отходит от классической генерации по тексту и работает через макеты: каждый визуальный элемент получает точные координаты, размер и описание. Модель прошла дополнительный пространственный претрейн на базе Qwen. Изображение представляется как код, что позволяет управлять результатом через промпт или точечно редактировать JSON-структуру макета. По заявлению авторов, на обучение ушло в 10 раз меньше вычислительных мощностей по сравнению с корпоративными аналогами. Модель занимает вторую строчку в бенчмарке Text-to-Image ArenaAi, обходя Nano Banana 2 и GPT-Image-1.5. blog.reve.com ✔️ Трафик ботов и ИИ-агентов впервые превысил активность людей По данным Cloudflare, доля машинного веб-трафика достигла 57,5%, превысив активность людей (42,5%). По словам гендиректора компании Мэттью Принса, рубеж пройден на несколько лет раньше прогнозируемого 2027 года. Рост обусловлен не классическими скриптами (краулеры, спам, DDoS-сети), а автономными ИИ-агентами. Алгоритмы парсят контент для обучения нейросетей и выполняют многошаговые задачи от лица пользователей: мониторят цены, взаимодействуют со службами поддержки и оформляют заказы. Cloudflare классифицирует трафик верифицированных ботов и ИИ-агентов отдельно с прошлого года. Точную дату превышения машинного трафика над человеческим определить сложно из-за специфики метрик. CEO CloudFlare в сети Х @ai_machinelearning_big_data #news #ai #ml

⚡️ Microsoft открыла Coreutils для Windows - знакомые Unix-команды теперь ставятся одной командой Microsoft выпустила первый релиз Coreutils for Windows. Это набор привычных *nix-инструментов для Windows, написанных на Rust. Внутри: - Rust-версия GNU Coreutils - реализация FindUtils - свежая реализация Grep - shim для совместимости с DOS sort и find - PowerShell-обёртка для glob-паттернов как в Unix Установка через winget:

winget install Microsoft.Coreutils

Интересный момент: GNU grep тоже переписали на Rust и уже выкатили первый релиз с тестами, бенчмарками и ранними контрибуциями. Пока это не финальная замена старым инструментам - в первом релизе ожидают баги и ещё есть работа по производительности. Но сам вектор понятен: Microsoft всё активнее тащит Unix-like tooling в Windows, а Rust становится нормальным языком для системных утилит. https://github.com/microsoft/coreutils

Rust Coreutils 0.9.0 вышел с важным обновлением: закрыли 44 уязвимости, но формальная совместимость с GNU Coreutils просела до 90,58%. Звучит как откат, но причина в другом. Тестовый набор обновили до GNU Coreutils 9.11, туда добавили 25 новых проверок. После этого uutils прошёл 625 тестов, а 56 завалил. В прошлой версии было 630 успешных и 21 неуспешный тест, отсюда падение с 94,74%. Самая важная часть релиза - безопасность. После аудита Zellic исправили 44 уязвимости. Много проблем было связано с расхождением поведения относительно GNU Coreutils и гонками файловой системы. Типичный сценарий: программа проверяет файл, а между проверкой и действием его успевают заменить на симлинк. Для обычного запуска это неприятно. Для cp, chmod или mv от root это уже критично: можно добиться копирования, изменения прав или перезаписи чужого файла. Для защиты усилили безопасное копирование через uucore::safe_copy. Параллельно продолжается техническая чистка: - id, tr, timeout, sort, wc, tail, cp, who, factor переводят на rustix - сокращают количество unsafe - в cat, wc, head, tail, yes, cp, tee, unexpand используют splice(), tee() и pipe() для работы без лишнего копирования данных - подтянули совместимость numfmt, date, tr, cksum, factor, head, stat, sort - для ln, dd, mktemp, tty добавили сборку под WebAssembly/WASI Хороший релиз именно для системного Rust. Здесь видно, что переписать coreutils на Rust - это не только «убрать C ради безопасности». Нужно годами догонять поведение GNU, ловить тонкие файловые гонки, вычищать unsafe и сохранять производительность на низком уровне. Совместимость временно просела, но проект стал безопаснее и технически чище. https://github.com/uutils/coreutils/releases/tag/0.9.0

👣 В Rust нашли интересный способ ускорить pretty printer - штуку, которая красиво форматирует код, JSON, Lisp и другие структуры. Обычно есть два подхода. Первый - собрать всё дерево документа целиком. Так делают Wadler-style pretty printers. Это выразительно, но в Rust быстро упирается в память, аллокации и указатели. Второй - стримить вывод по кускам. Так работает Oppen-style подход. Он легче по памяти, но часто принимает локально хорошие решения и не всегда находит глобально лучший layout. Автор предлагает третий вариант: не хранить документ как рекурсивный enum, а описывать его через trait Doc. То есть Text, Concat, Group, Nest и другие элементы становятся отдельными типами, которые умеют сами себя рендерить через layout(). Звучит как мелкая архитектурная правка, но эффект большой: меньше лишних аллокаций, меньше прыжков по памяти, гибче управление Box, Rc и другими стратегиями хранения. В proof-of-concept реализации pye автор получил до 60x ускорения по сравнению с прямой Rust-реализацией алгоритма из paper “A Pretty Expressive Printer”. А в обновлённых тестах вариант с таким дизайном и greedy-алгоритмом местами обгонял pretty и arena-версию больше чем в 10 раз. В Rust производительность часто ломается не только на алгоритме, но и на форме данных. Иногда enum выглядит красиво, но trait-based дизайн лучше ложится на память, ownership и реальные оптимизации компилятора. blog.wybxc.cc/blog/pretty-printer-pye/ #Rust #RustLang #Compilers #OpenSource #SystemsProgramming

🦀 Rust 1.96 вышел: новые range-типы, удобные assert-матчи и важное изменение для WebAssembly Rust 1.96.0 выглядит как минорный релиз, но внутри есть несколько вещей, которые реально стоит заметить. Главное изменение - новые core::range::Range* типы. Старые Range из core::ops напрямую реализуют Iterator, поэтому их нельзя нормально сделать Copy без неприятных ловушек. Новые range-типы идут другим путём: они реализуют IntoIterator, а значит могут быть Copy. Теперь можно хранить диапазоны в Copy`-структурах без костылей вроде раздельных `start и end.

use core::range::Range;

#[derive(Clone, Copy)]
pub struct Span(Range<usize>);

Ещё одно приятное обновление - assert_matches! и debug_assert_matches!. Это как assert!(matches!(...)), только при падении выводится значение через Debug, а значит тесты и отладка становятся заметно понятнее. Макросы не добавили в prelude, их нужно импортировать вручную из core или std. Для WebAssembly есть изменение построже: undefined symbols теперь становятся ошибкой линковки, а не молча превращаются в импорты из "env". Это может сломать часть старых сборок, зато такие проблемы теперь ловятся раньше, а не всплывают странным поведением на рантайме. Из важного по безопасности: в Rust 1.96 исправлены две уязвимости Cargo для пользователей сторонних registry. Пользователей crates.io они не затрагивают. Обновление стандартное:

rustup update stable

Релиз без фейерверков, но полезный: меньше footgun'ов с range, удобнее проверки в тестах, строже WebAssembly-сборки и пара закрытых дыр в Cargo. https://blog.rust-lang.org/2026/05/28/Rust-1.96.0/

🌐 Умный DNS-резолвер Numa Numa - это портативный DNS-резолвер, который работает из одного бинарного файла. Он блокирует рекламу, позволяет настраивать локальные сервисы и шифрует запросы с помощью ODoH, обеспечивая вашу конфиденциальность. Все функции встроены, без необходимости в облачных сервисах. 🚀 Основные моменты: - Портативный, работает на любом устройстве. - Блокировка рекламы и кэширование по умолчанию. - Поддержка DNSSEC и DNS-over-TLS для шифрования. - Автоматическое обнаружение устройств в локальной сети. - Легкий в использовании интерфейс и настройка. 📌 GitHub: https://github.com/razvandimescu/numa