Apple устраивает «щёлчок Таноса» с iOS, а большинство разработчиков даже не заметили этого. Тихо, за кулисами, части iOS переписываются не на Swift и не на Objective-C, а на языке, который половина комьюнити до сих пор шутя называет случайным ASCII‑артом, рассыпанным по клавиатуре.
Ага. Пока вы боретесь со сбоями в Xcode в два часа ночи или пытаетесь убедить своё приложение прекратить случайные выдачи ошибок EXC_BAD_ACCESS, инженеры Apple переписывают код прямо у вас под ногами. И это не слухи: вакансии, утекшие коммиты и хлебные крошки сообщества указывают на то, что Apple внедряет Rust в экосистему iOS. И если вы работаете в этой сфере достаточно давно, то знаете, что Apple не «экспериментирует» просто так.
Почему это важно? Поскольку Apple переходит от базовых C/Obj-C к безопасным для памяти и дружественным к параллелизму системным языкам, ваши приложения (и весь стек iOS) могут работать быстрее, реже зависать и, возможно, даже перестанут вызывать у вас сомнения в выборе карьеры.
TLDR: Apple переписывает ключевые части iOS на Rust для обеспечения безопасности и производительности. Это не убивает Swift, но означает, что фундамент Swift меняется. Меньше сбоев, лучшая безопасность и, возможно, начало будущего, основанного на Rust, для разработчиков iOS.
Главное открытие
Итак, что же именно делает Apple? В истинно купертиновском стиле они не выпустили громкий пресс-релиз или доклад. Вместо этого они вносят изменения в объявления о вакансиях, документацию для разработчиков, и, если присмотреться, коммиты в репозиториях указывают на нечто важное: внутренние компоненты iOS переписываются на Rust-подобном системном языке.
Речь идёт не о приложениях, которые вы пишете в Xcode, и не о кнопках SwiftUI, о которых вы спорите в Twitter. Мы говорим о сути iOS: уровнях управления памятью, критически важных для безопасности фреймворках и тех низкоуровневых модулях ОС, о которых вы слышите только тогда, когда они ломаются и уносят с собой половину вашего приложения.
Например, в вакансиях Apple за последние два года явно упоминался опыт работы с Rust для системных инженеров. Не с Swift. Не с «волшебством C++». Rust. Это как если бы Nintendo объявила о поиске нового разработчика Zelda и искала бы специалистов по Unreal Engine — вы бы поняли, что они настроены серьёзно.
И нетрудно догадаться, почему. Rust обеспечивает безопасность памяти, многопоточность без чёрной магии и производительность, которая заставляет разработчиков на C кивать в знак уважения. Для компании, которая патчит переполнение буфера со времён iPod, это, по сути, бесплатная страховка от очередного пиар-провала с «ошибкой FaceTime, позволяющей незнакомцам вас подслушивать».
Лучшая аналогия? Представьте, что Apple меняет двигатели самолёта прямо в полёте. Пассажиры (то есть мы, разработчики iOS) продолжают потягивать бесплатный Sprite и создавать приложения, в то время как под капотом двигатели и вся система заменяются на что-то более быстрое, безопасное и гораздо более устойчивое к крушениям.
Это не незначительное обновление, а тектонический сдвиг. И он происходит тихо, потому что Apple знает, что как только они это подтвердят, Reddit, Hacker News и все разработчики на Discord примутся это обсуждать.
Почему Swift оказалось недостаточно
Когда Swift презентовали в 2014 году, казалось, что Apple наконец-то даёт разработчикам современное оружие вместо ржавого кинжала. Прощай, квадратные скобки Objective-C повсюду, привет чистому синтаксису, опциональным переменным и типобезопасности, не требующей жертвоприношения каждый раз при выделении памяти. Какое-то время казалось, что именно в этом будущее разработки для iOS и macOS.
Но вот реальность: Swift — не системный язык. Он построен на десятилетиях развития C и Objective-C. Ваша блестящая иерархия представлений SwiftUI? Всё ещё опирается на фреймворки старой школы Cocoa, написанные на C. Компилятор Swift, возможно, и убережёт вас от спотыкания о нулевые указатели, но он не избавит вас волшебным образом от того, что под капотом вы всё ещё имеете дело с древним кодом, который больше похож на клейкую ленту, чем на титан.
А безопасность памяти? Лучше, но не пуленепробиваемая. Swift может предотвратить самые глупые ошибки, но когда он взаимодействует с устаревшими API C, вы снова оказываетесь в мире EXC_BAD_ACCESS. Каждый знакомый мне разработчик iOS сталкивался с падением в рантайме, связанным с «неожиданно найденным nil», и задавался вопросом: почему это всё ещё происходит в 2025 году?
Параллелизм — ещё одна больная тема. Сахар Swift async/await неплох, но по сравнению с проверкой заимствований Rust и бесстрашной моделью параллелизма он кажется пластырем на пулевой ране.
Apple чётко понимала, что Swift не может быть панацеей от всего. Он отлично подходит для работы на уровне приложений, но когда вы патчите ядра, пишете драйверы или работаете с криптографией, вам не нужен «почти безопасный» язык. Вам нужны несокрушимые гарантии.
Так что если Swift был «красивым, современным, удобным для разработчиков» слоем, то Rust превращается в броню под ним. Apple не потерпела неудачу со Swift, они просто поняли, что этого недостаточно, чтобы выстроить надежный фундамент.
Расцвет Rust в Big Tech
Раньше Rust был тем необычным языком, о котором вы слышали от своего друга-хипстера, который также использует Arch Linux и обожает фреймовые оконные менеджеры. Прошло десять лет, и внезапно каждый гигант высоких технологий начал добавлять Rust в свои разработки, словно это тот самый секретный ингредиент, которого им не хватало.
Microsoft? Они используют Rust в ядре Windows для новых критически важных для безопасности компонентов. Google? Встроил поддержку Rust в низкоуровневые слои Android, потому что C++ был, по сути, бесконечной вечеринкой утечек памяти. Amazon? AWS Firecracker: да, та же технология microVM, что и в Lambda, написана на Rust. Даже Meta* подключилась, продвигая внедрение Rust для бэкенд-сервисов и открывая исходный код внутренних контейнеров.
Закон очевиден: если вы работаете в глобальном масштабе, где одна ошибка может стоить миллионы или стать новостью на первых полосах, C и C++ начинают казаться бомбами замедленного действия. Rust не заставляет бомбы исчезнуть, но даёт вам компилятор, который кричит на вас, пока вы их как следует не обезвредите.
А Apple? Они странно молчали. Пока все остальные писали посты в блогах и расхваливали внедрение Rust на Hacker News, Apple оставалась в скрытом режиме. Что, честно говоря, вполне в духе бренда. Они предпочли бы тихо внедрить его в iOS и macOS, а затем небрежно заявить на WWDC: «Кстати, мы переписали половину Darwin на Rust», как будто это не такая уж большая проблема.
Так что нет, Apple не просто экспериментирует. Они опоздали на публичную вечеринку Rust, но, если верить истории, они появятся, перевернут стол и переопределят ход дискуссии, как это было с чипами ARM, пока Intel ещё возилась с термопастой.
Что это значит для разработчиков iOS
Итак, Apple тихо меняет движок на лету. Но что это значит для нас, разработчиков, которые просто пытаются получить одобрение своих приложений без очередного письма об отказе в App Store в два часа ночи?
В краткосрочной перспективе? Честно говоря, не так много. Вы не запустите Xcode завтра и не обнаружите шаблон «Новый проект на Rust» рядом со SwiftUI. Ваши вызовы UIKit по-прежнему будут работать, Swift по-прежнему компилироваться, а ваше приложение будет продолжать падать из-за тех же глупых логических ошибок, которые вы сами написали (извините, компилятор вас не исправит).
Но в долгосрочной перспективе? Вот тут-то и начинается самое интересное. Если Apple переписывает основы на Rust, вы увидите:
- Более безопасные фреймворки → Меньше случайных ошибок в рантайме типа «неожиданно найденный nil».
- Повышенная производительность → Низкоуровневая эффективность Rust может сделать прокрутку списков более плавной, не требуя от вас ни единой строчки кода.
- Более безопасная ОС → меньше шансов на появление уязвимости нулевого дня в стиле FaceTime.
И вот неожиданный поворот: если Apple когда-нибудь раскроет API Rust, пусть даже частично, это может открыть двери для совершенно новой волны разработчиков iOS, которые никогда не прикасались к Swift, но любят системное программирование. Представьте себе будущее, в котором часть логики вашего приложения может работать на безопасном и быстром Rust, а пользовательский интерфейс останется на Swift.
Мини история: однажды я потратил две недели на поиск ошибки в UIKit, которая оказалась старой утечкой памяти Objective-C, скрывающейся в тени. Если Apple перепишет этот фреймворк на Rust, ошибка не просто будет исправлена, она исчезнет. Вот о каком невидимом волшебстве мы говорим.
Для нас повседневная жизнь не изменится сразу. Но фундамент Swift меняется, и если вы этого не заметите, то, возможно, проснётесь на какой-нибудь WWDC и осознаете, что стоите на Rust.
Моё мнение
Действие Apple выглядит так, будто они тихо признали то, что многие из нас уже подозревали: Swift никогда не был финальной точкой. Не поймите меня неправильно, мне на самом деле нравится Swift. Он легко читается, достаточно быстр и гораздо лучше, чем жонглирование квадратными скобками и ручными церемониями retain/release в Objective-C. Но когда вы патчите ядра или защищаете криптографические библиотеки, Swift больше похож на дружелюбный слой пользовательского интерфейса поверх гораздо более страшной машины.
Для разработчиков этот сдвиг — это, по сути, победа. Больше стабильности означает меньше сбоев, заставляющих вас задуматься, почему вы просто не стали бариста. Лучшая безопасность означает меньше неловких заголовков об ошибках iOS, позволяющих подслушивать ваши звонки в FaceTime. И честно говоря? Если Apple использует Rust для укрепления фундамента, это лучшее изменение, которое облегчит вам жизнь, не требуя переписывания всей кодовой базы.
Тем не менее, я не надеваю розовые очки. Существует реальный риск фрагментации экосистемы. Если Apple начнёт смешивать Rust, Swift и какой-нибудь старый Obj-C в качестве связующего материала, всё это может быть больше похоже на башню дженга, чем на чёткую, унифицированную языковую стратегию. А если они когда-нибудь всё же представят API Rust, можете быть уверены, что кривая обучения новичков резко возрастёт.
Это как если бы Apple сказала нам, что Swift — это Tesla, блестящее, современное будущее. А потом, на полпути, они незаметно заменили внутри электричество на дизельный двигатель Rust. Он всё ещё едет быстрее, но не покидает ощущение, что всё изменилось прямо на ходу.
Что дальше?
Если верить истории, Apple не идет на полумеры. Выбрав направление, они идут ва-банк — просто спросите Intel, как прошёл переход на Apple Silicon. Так что если они сегодня внедряют Rust во внутренние компоненты iOS, не удивляйтесь, если к iOS 20 ОС будет полностью основана на Rust.
Как это выглядит? Для начала, более тесное взаимодействие Swift и Rust. Apple не будет отказываться от Swift, поскольку он слишком глубоко укоренился в экосистеме, но может незаметно расширить набор инструментов, чтобы низкоуровневые фреймворки были переписаны на Rust, в то время как Swift останется «лицом» разработки. Представьте Swift как слой пользовательского интерфейса, в то время как Rust выполняет грязную работу «под капотом».
Есть и более широкий отраслевой контекст. Linux уже интегрировал Rust в ядро. Microsoft внедряет его в Windows. Даже браузеры (Firefox с Servo, эксперименты с Chrome) заигрывали с Rust для повышения производительности и безопасности памяти. Apple обычно не первая, но когда появляется, она навязывает стандарт.
Так что вот моя ставка: через год-два на WWDC какой-нибудь инженер выйдет на сцену и небрежно обронит: «UIKit был переработан с использованием Rust для повышения надежности». Толпа вежливо поаплодирует, но каждый разработчик в зале поймет, что ситуация только что кардинально изменилась.
Вопрос не в том, станет ли Rust частью истории разработки для iOS, а в том, когда Apple решит, что мы готовы о нём услышать. А пока что нам лучше всего? Продолжать разрабатывать на Swift, но, возможно, сдуть пыль с книги по Rust на полке. Позже скажете себе спасибо.
Заключение
В конечном счёте, переписывание Apple внутренних компонентов iOS на Rust (или системных языках, подобных Rust) — это не предательство Swift, а эволюция. Swift никогда не задумывался как язык для защиты ядра или управления памятью на самых низких уровнях. Он был инструментом, повышающим продуктивность разработчиков, а приложения — выразительностью. И он с этим справился.
Но если отойти от этой темы, всё становится ясно. Swift, возможно, и остаётся красивым элементом пользовательского интерфейса, но настоящая тяжелая работа, лежащая в основе, — это переход к Rust. Это может быть неприятно для ярых приверженцев Swift, но, честно говоря, да? Это хорошо для нас. Меньше сбоев, меньше эксплойтов нулевого дня и меньше времени, потраченного на поиск фантомных ошибок, спрятанных в связующем коде Objective-C.
Вот несколько спорное мнение: через пять лет Swift может стать JavaScript экосистемы Apple, отличным для фронтенда, но не основой ядра. Rust (или его аналог, вдохновлённый Rust) станет основой. И когда это произойдёт, вы либо будете готовы, либо будете гуглить «руководство по Rust» в 3 часа ночи, когда ваш CI/CD-конвейер даст сбой.
Так что, возможно, сейчас лучшее решение — не паника, а любопытство. Потому что основы разработки iOS меняются, и, нравится вам это или нет, Rust — часть вашего будущего.