🔥 Burn — Rust-фреймворк для глубокого обучения с акцентом на производительность. В отличие от монолитных решений вроде PyTorch, Burn изначально заточен под кросс-платформенное выполнение: одна и та же модель может работать на NVIDIA/AMD GPU через CUDA/ROCm, на Apple-чипах через Metal и даже в браузере через WebGPU.

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

🤖 GitHub

💫 GlueSQL — SQL-движок, превращающий любые данные в полноценную базу данных. Этот инструмент умеет выполнять JOIN между CSV и MongoDB, работать с Git как с хранилищем данных и даже запускать SQL-запросы прямо в браузере через WebAssembly.

Что отличает GlueSQL от классических СУБД?
- Поддержка schemaless-данных
- Встроенные адаптеры для 10+ форматов
- Возможность добавлять свои хранилища через реализацию двух traits на Rust

Проект активно развивается: недавно добавили поддержку транзакций в Sled-бэкенде и анонсировали облачную версию. Для теста достаточно cargo add gluesql и уже можно писать SQL-запросы к данным в памяти.

🤖 GitHub

Senior Rust Developer в BlockSniper
Удалёнка | full-time | 400–700K ₽ + премии
Мы лидеры в снайпинге токенов на Solana. Пишем трейдинг-ботов и высокоскоростные стратегии. Уже 4 года в деле, 50 человек в команде, работаем без бюрократии — только результат. Премии от прибыли: топы получают +300K к зп.

💻 Что важно:
— Опыт в Rust, Solana (Anchor, CLI, деплой)
— Знание JS/TS, понимание RPC/DApps/PoS
— Опыт с HFT, трейдингом или ботами
— Умение вести проект от идеи до продакшена

🧩 Ищем тех, кто не боится челленджей:
у нас нужно разбираться, предлагать, выстраивать. Самостоятельность — must-have. Взамен даём максимум свободы, зп и роста.

🎁 Можете быть уверены в:
— Конкурентной зп + доход от прибыли команды
— Полной удаленке, оплачиваемом отпуске и больничном
— Том, что мы вкладываемся в рост: обсуждаем бенефиты, помогаем развиваться

Напиши нашему HR Маргарите 👉 @m_dereviakina, если ищешь место, где можно развиваться, расти и хорошо зарабатывать.

Virviil/oci2git

Это консольное приложение на Rust, которое преобразует контейнерные образы (Docker и др.) в Git-репозитории. Каждая слоя образа превращается в отдельный коммит, что позволяет сохранять всю историю и структуру исходного образа

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

- Поддержка разбора Docker-образов и извлечения информации о слоях.

- Генерация Git-репозитория, где каждый слой соответствует одному коммиту (включая «пустые» слои вроде ENV и WORKDIR)


- Экспорт всей метаинформации об образе в файл Image.md в формате Markdown.

- Расширяемая архитектура для работы с разными движками контейнеров (docker, nerdctl, tar)

- Типичные сценарии использования:

- Сравнение слоёв (Layer Diffing): благодаря git diff можно увидеть точные изменения между любыми двумя слоями образа и выявить, какие файлы были добавлены, изменены или удалены

- Отслеживание происхождения (Origin Tracking): команда git blame помогает быстро понять, в каком слое и какой Dockerfile-инструкции был впервые создан или изменён конкретный файл
GitHub

- История файла (File Lifecycle): с помощью git log --follow можно проследить путь любого файла через все слои: от создания до удаления
GitHub

- Исследование слоёв (Layer Exploration): переключаясь на любой коммит, вы получаете файловую систему образа в состоянии этого слоя, что удобно для отладки и аудита безопасности

Github

🦀 Rust-задача с подвохом: “Ловушка безопасного кэша”

📘 Условие

Ты хочешь реализовать простой кэш — если значение уже вычислено, вернуть его, иначе — сохранить и вернуть.

Вот пример:

use std::collections::HashMap;

fn main() {
    let mut cache = HashMap::new();
    let key = "user_123".to_string();

    let result = get_or_insert(&mut cache, &key, || {
        println!("Computing...");
        "result for user_123".to_string()
    });

    println!("Result: {}", result);
}

fn get_or_insert<'a, F>(map: &'a mut HashMap<String, String>, key: &str, compute: F) -> &'a String
where
    F: FnOnce() -> String,
{
    map.entry(key.to_string()).or_insert_with(compute)
}

❓ Вопрос:

1) Почему этот код не компилируется, хотя кажется безопасным?
2) Где именно проблема с lifetime'ами?
3) Как можно переписать этот код так, чтобы он компилировался и оставался эффективным?

---

✅ Подвох и разбор

💥 Проблема в or_insert_with(compute) и владении ключом.

Метод .entry() требует ключ во владение (`String`), а key у нас — &str.
Внутри or_insert_with происходит вызов compute(), который может вернуть ссылку на строку, но Rust не может доказать, что ссылка будет жить достаточно долго.

Но главная причина — возвращаемое значение &'a String, полученное из HashMap::entry, не может быть безопасно связано с временем жизни `map`, потому что key.to_string() создаёт временное значение, и lifetime не совместим.

📌 Ошибка компилятора: borrow may not live long enough.

✅ Как исправить

Вариант 1 — использовать `Entry` напрямую и разбить на шаги:

```rust
fn get_or_insert<'a, F>(map: &'a mut HashMap<String, String>, key: &str, compute: F) -> &'a String
where
F: FnOnce() -> String,
{
use std::collections::hash_map::Entry;

match map.entry(key.to_string()) {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => entry.insert(compute()),
}
}
```

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

---

⚠️ Подвох

• `.or_insert_with(...)` выглядит безопасным, но может скрывать временные владения
• Проблемы начинаются, когда `key.to_string()` создаёт временное значение, и Rust не может связать его lifetime
• Даже опытные разработчики удивляются ошибке компилятора, потому что map.entry().or_insert_with() выглядит «канонично»

🎯 Отлично подходит для проверки глубокого понимания владения и жизненных циклов в Rust.

🚀 Nova — новый движок JavaScript/Wasбm на Rust. Этот экспериментальный проект пытается переосмыслить архитектуру JS-движков через призму data-oriented design. Вместо классических указателей Nova использует индексы и векторы, чтобы минимизировать накладные расходы и улучшить кэширование.

Пока движок далёк от готовности, но подход к разработке вызывает интерес, например safepoint garbage collector, построенный на особенностях системы заимствований Rust — это попытка максимально приблизить структуру кода к ECMAScript-спецификации.

🤖 GitHub

🎉 С днём рождения, Rust! 🦀

10 лет с момента выхода Rust 1.0 — языка, который подарил миру безопасное, быстое и конкурентное программирование.

Отпразднуем вместе с невероятным сообществом и тысячами проектов, созданных на Rust!

#rust #Rust10Years #программирование

https://blog.rust-lang.org/2015/05/15/Rust-1.0/

Выпуск Rust 1.87

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

- Оптимизации компилятора: Улучшена производительность компиляции, особенно для крупных проектов, что сокращает время сборки.

- Расширения стандартной библиотеки: Добавлены новые функции и улучшены существующие модули, такие как std::fs и std::net, что упрощает разработку приложений.

- Улучшения в работе с асинхронным кодом: Обновления в async/await механизмах обеспечивают более стабильную и предсказуемую работу асинхронных операций.

Полный список изменений и подробности:http

📌 napi-rs — мост между Node.js и Rust. Это фреймворк для создания нативных расширений Node.js на Rust через Node-API, без необходимости работать с node-gyp или другими инструментами сборки C++.

Достаточно добавить аннотацию #[napi] к Rust-функциям и они становятся доступными в JavaScript как обычные модули. Под капотом napi-rs автоматически генерирует binding-код, поддерживает асинхронные операции через tokio и даже предоставляет CLI для удобной сборки. Собранные `.node`-файлы работают на Windows, macOS, Linux и даже Android.

🤖 GitHub

🦀 Задача на Rust: "Найди пропавшее число"

Условие
У тебя есть Vec<String>, в котором находятся строки от "1" до "100", но одно число отсутствует.
Найди его без использования sort, HashMap, iter().sum() и т. д.
Можно использовать parse::<u32>().

Формат функции:

fn find_missing_number(data: &Vec<String>) -> u32

Решение через XOR:

fn find_missing_number(data: &Vec<String>) -> u32 {
    let mut xor_full = 0;
    let mut xor_data = 0;

    for i in 1..=100 {
        xor_full ^= i;
    }

    for s in data {
        if let Ok(n) = s.parse::<u32>() {
            xor_data ^= n;
        }
    }

    xor_full ^ xor_data
}

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

fn main() {
    let mut data: Vec<String> = (1..=100)
        .filter(|&x| x != 42)
        .map(|x| x.to_string())
        .collect();

    use rand::seq::SliceRandom;
    let mut rng = rand::thread_rng();
    data.shuffle(&mut rng);

    let missing = find_missing_number(&data);
    println!("Пропущено: {}", missing); // Ожидается 42
}

Зависимости в `Cargo.toml`:

[dependencies]
rand = "0.8"

Объяснение:
XOR всех чисел от 1 до 100 ⊕ XOR из входных данных → пропущенное число.
Работает, потому что a ^ a = 0, 0 ^ b = b.

🦀 Как упростить изучение Rust: советы от Corrode

Rust — мощный и надёжный язык, но его обучение часто вызывает трудности даже у опытных разработчиков. В свежем блоге [Corrode Rust Consulting](https://corrode.dev/blog/flattening-rusts-learning-curve/) делятся рекомендациями, как сгладить кривую обучения Rust без боли и выгорания.

🔑 Основные советы:

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

- Начинайте с "грязных" решений
Используйте clone(), unwrap(), expect() на старте — позже замените на идиоматичный и безопасный код.

- Учитесь постепенно
Разбивайте обучение на этапы, пишите много маленьких программ в [Rust Playground](https://play.rust-lang.org/).

- Читайте ошибки компилятора вдумчиво
В Rust компилятор — это не враг, а учитель. Он подсказывает, как мыслить «по-растовски».

- Пишите вручную, не полагайтесь на IDE
Автокомплит мешает усвоению синтаксиса — набирайте код вручную, чтобы лучше понять структуру.

- Проектируйте через типы
Rust даёт мощную систему типов — используйте её как инструмент проектирования, а не просто проверки.

📖 Полный текст: https://corrode.dev/blog/flattening-rusts-learning-curve/

Хороший Rust-разработчик — не тот, кто никогда не ошибается, а тот, кто умеет читать сообщения компилятора и не сдаваться.

RustScan – Инструмент для быстрого сканирования портов

Данный проект может похвастаться высокой скоростью работы(Сканирует все 65 тыс. портов за 3 секунды), гибкой расширяемостью и адаптивным методом работы.

https://github.com/bee-san/RustScan

🦀 Rust и магия динамики: как создать Python‑подобный API с помощью Serde

В новой статье *Ohad Dravid* демонстрирует, как в языке Rust можно добиться удобства динамического доступа к данным — в духе Python — но без потери строгой типизации и производительности. Всё это — с помощью мощной библиотеки serde.

📌 Статья: *“A Rust API Inspired by Python, Powered by Serde”*
🔗 [ohadravid.github.io/posts/2025-05-serde-reflect](https://ohadravid.github.io/posts/2025-05-serde-reflect/)

🔍 Проблема

Python позволяет обращаться к произвольным полям объектов, например при работе с WMI:

for fan in c.Win32_Fan():
    print(fan.Name, fan.DesiredSpeed)

А вот Rust требует ручной работы: если вы хотите получить поле объекта по имени — нужно писать get_attr, делать match, проверять типы и всё это каждый раз.

🙄 Это:
- многословно,
- подвержено ошибкам,
- неудобно для пользователя API.

🎯 Цель

Сделать API на Rust, который позволял бы:

1. Писать простой, декларативный код
2. Избегать ручной сериализации и проверки типов
3. Получать строго типизированные структуры из «сырых» данных

И всё это — без хаков и макросов, а с помощью serde и аккуратной архитектуры.

⚙️ Как это реализовано

Охад реализует три версии API:

🛠 1. raw_api.rs — примитивный уровень

pub enum Value { Bool(bool), I1(i8), UI8(u64), String(String), Object(Object) }

impl Object {
    pub fn get_attr(&self, name: &str) -> Value { /* ... */ }
}

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

✨ 2. v1_api.rs — пользователь сам описывает структуру + ручная десериализация

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

🚀 3. v2_api.rs — Serde‑магию включено

Теперь query() возвращает Vec<T>:

#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct Fan {
    name: String,
    active_cooling: bool,
    desired_speed: u64,
}

let res: Vec<Fan> = query();
for fan in res {
    if fan.active_cooling {
        println!("Fan `{}` is running at {} RPM", fan.name, fan.desired_speed);
    }
}

Теперь:
- никакой ручной сериализации
- никаких match
- всё строго типизировано и работает с минимальными затратами

🧠 Как это работает под капотом

Проект использует:

• serde::Deserialize
• внутренний модуль meta.rs, который:
- извлекает названия полей и их типы
- генерирует SQL‑подобный запрос под структуру
- использует эти поля для сопоставления данных

API получается универсальным: любую структуру, которая реализует Deserialize, можно использовать как результат запроса.

📈 Почему это важно

✅ Приближает Rust к удобству Python, сохраняя безопасность
✅ Минимизирует дублирование кода
✅ Даёт мощный, типобезопасный интерфейс над динамическими структурами
✅ Применимо к WMI, COM, JSON API, SQL‑слоям и множеству других задач

🔭 Возможности расширения

- Генерация запросов по структурам (`SELECT ... FROM ... WHERE ...`)
- Интеграция с внешними API (WMI, COM)
- Расширение в сторону serde-reflection для полного introspection
- Создание DSL поверх API для ещё более лаконичного запроса данных

📚 Заключение

Rust и serde — это не только про производительность и безопасность, но и про удобный API, если правильно подойти к задаче. Этот проект показывает, как можно сделать гибкий, декларативный, типобезопасный интерфейс для работы с данными — без костылей и магии рантайма.

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

🔗 Читай подробнее: [ohadravid.github.io/posts/2025-05-serde-reflect](https://ohadravid.github.io/posts/2025-05-serde-reflect/)\

⚡️ Pydantic Core — Rust-ядро для валидации данных в Python. Этот низкоуровневый валидатор демонстрирует впечатляющую скорость: до 17x быстрее оригинальной реализации на чистом Python.

Хотя напрямую с ним обычно не работают (используя вместо этого основной пакет pydantic), проект интересен как пример интеграции Rust в Python-экосистему. Валидация описывается через JSON-схемы, поддерживая сложные условия вроде ge: 18 для чисел или вложенных структур. Сборка требует Rust toolchain, но результат стоит того: например, валидация списка из 10к элементов занимает миллисекунды.

🤖 GitHub

🦀 Rust понижает поддержку 32-битной сборки для Windows (i686-pc-windows-gnu)

26 мая 2025 года команда Rust официально объявила: начиная с версии Rust 1.88.0, цель i686-pc-windows-gnu (32-битная сборка под Windows с GNU toolchain) больше не будет Tier 1. Её статус понижен до Tier 2 с поддержкой хост-инструментов.

🔧 Что изменится:
• Бинарники и стандартная библиотека по-прежнему будут доступны через rustup
• Однако автоматическое тестирование на CI сокращается
• Возможны баги и сниженная стабильность без гарантий быстрой починки

📉 Почему так:
• Нет активных мейнтейнеров для *-windows-gnu целей
• Сложно отлаживать ошибки без специалистов
• 32-битная сборка почти не используется в сравнении с x86_64-pc-windows-gnu

📌 Что дальше:
Если ситуация не изменится, возможен полный отказ от поддержки этой цели. Сообщество Rust призывает желающих подключиться к поддержке *-windows-gnu.

📖 Подробнее:
https://rust-lang.github.io/rfcs/3771-demote-i686-pc-windows-gnu.html

@rust_code

🦀 Победа для всего Rust-сообщества: состоялся релиз Linux 6.15 — и он действительно важный

Новый релиз ядра Linux 6.15 — не просто очередное обновление. Это первая версия, где Rust-код стал частью реального продакшн-функционала ядра, а не просто экспериментом.

🔥 Что нового:
• Поддержка Rust в драйверах и подсистемах (в том числе networking)
• Начало перехода некоторых компонентов с C на memory-safe Rust
• Улучшена совместимость с архитектурами RISC-V и ARM
• Обновления в системах безопасности, файловых системах и планировщике задач

💬 Линус Торвальдс уже заявил, что Rust — это будущее для многих чувствительных компонентов ядра, особенно в мире, где безопасность становится ключевым фактором.

📌 Rust в ядре — это не просто «новый язык». Это переход к более безопасной, надёжной и современной экосистеме Linux.

🔗 Подробнее:
https://www.zdnet.com/article/the-linux-6-15-kernel-arrives-and-its-big-a-victory-for-rust-fans/

@rust_code

🔥 From C# to Rust: 42-дневный челлендж от Chris Woody Woodruff

Chris Woodruff, экспериментающий .NET-разработчик, объявил старт своего 42-дневного пути погружения в Rust — язык системного программирования, совмещающий производительность, безопасность и отсутствие null:contentReference[oaicite:0]{index=0}.

🎯 Цели проекта
- Жить и дышать Rust — по одному уроку в день.
- Противостоять строгому borrow checker.
- Осознанно учиться и делиться выводами от лица C#-разработчика.

🛠 Что ожидается изучить
- Владение памятью, шаблоны, трейты, времена жизни (`lifetimes`).
- Яркие сравнения Rust и C#: синтаксис, ownership vs GC, ошибки компилятора:contentReference[oaicite:2]{index=2}.
- Краткие ежедневные отражения из .NET-мира.

📅 Примерный план на 42 дня
1. День 1–7: Почему Rust? Установка, cargo new vs dotnet new, "Hello, World!", переменные, функции:contentReference[oaicite:4]{index=4}.
2. День 8–14: Неделя владения — темы: ownership, borrowing, borrow checker:contentReference[oaicite:5]{index=5}.
3. День 15–42: Структуры, перечисления (`enum`), match, Option<T>, Result<T, E>, модули, ошибки, трейты, дженерики, лямбды и многое другое.

💬 Голос из сообщества
> «What happens when a C# dev swaps null for Option, garbage collection for ownership… You get 42 days of brain‑bending, compiler‑fighting…»

✨ Подытожим
- Проект идёт с апреля 2025 года, уже опубликованы десятки дневных эссе.
- Каждая запись по мотивам реального опыта: «why won’t this compile?!», сравнения с привычным C#.
- В финале — обзор полученного опыта, личные инсайты и примеры рабочего CLI‑приложения на Rust:contentReference[oaicite:8]{index=8}.

🚀 Готовы бросить вызов себе и глубже понять Rust?

Следите за дневником Woody и за входом в мир безопасных без‑GC систем прямо с .NET-опытов!

🔗 Подробнее: From C# to Rust: A 42-Day Developer Challenge

https://woodruff.dev/from-c-to-rust-a-42-day-developer-challenge/

🎯 Задача на владение (ownership) и ссылки в Rust

Напиши функцию longest_word<'a>(a: &'a str, b: &'a str) -> &'a str,
которая возвращает слово с наибольшей длиной из двух строк.

Но есть ограничение: ты не можешь копировать строки — только возвращать ссылку.

📌 Пример:

fn main() {
    let s1 = String::from("pirate");
    let s2 = String::from("gold");

    let result = longest_word(&s1, &s2);
    println!("Longest: {}", result); // 👉 "pirate"
}

🔍 Подсказка:

- Тебе нужно указать время жизни `'a` для всех аргументов и возвращаемого значения.
- Если ты не укажешь 'a, компилятор не поймёт, какая ссылка может жить дольше.
- Возвращать String нельзя — только &str (ссылка на строку).

🚫 Нельзя:

return a.to_string(); // ❌ копирование строки


✅ Можно:

return a; // ✅ ссылка

@rust_code