{"id":34291,"date":"2022-02-09T11:03:28","date_gmt":"2022-02-09T10:03:28","guid":{"rendered":"https:\/\/www.inovex.de\/?p=34291"},"modified":"2022-11-21T15:39:46","modified_gmt":"2022-11-21T14:39:46","slug":"rust-for-embedded-is-it-ready-yet","status":"publish","type":"post","link":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/","title":{"rendered":"Rust for Embedded &#8211; Is It Ready Yet?"},"content":{"rendered":"<p>Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.<!--more--><\/p>\n<p>The Rust language represents itself as a perfect match for system programming and doing rather low-level tasks without the well-known pains that can be currently experienced with C and C++ especially from a security point of view. On their embedded specific web page (a programming language that has a webpage that is explicitly targeting embedded development?! ), the Rust creators do answer the question: Why use Rust (for embedded devices)? with the following points:<\/p>\n<ul>\n<li>Powerful static analysis<\/li>\n<li>Flexible memory<\/li>\n<li>Fearless concurrency<\/li>\n<li>Interoperability<\/li>\n<li>Portability<\/li>\n<li>Community-driven<\/li>\n<\/ul>\n<p>Let us have a look at the details of their promises, how they stand up to a closer look and if Rust can match the needs and requirements we have for a programming language in the embedded environment.<\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_79_2 counter-hierarchy ez-toc-counter ez-toc-custom ez-toc-container-direction\">\n<div class=\"ez-toc-title-container\"><p class=\"ez-toc-title\" style=\"cursor:inherit\"><\/p>\n<\/div><nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#Powerful-static-analysis\" >Powerful static analysis<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#Flexible-memory\" >Flexible memory<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#Fearless-concurrency\" >Fearless concurrency<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#Portability\" >Portability<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#Community-driven\" >Community-driven<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#Interoperability\" >Interoperability<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#And-in-the-end\" >And in the end?<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"Powerful-static-analysis\"><\/span>Powerful static analysis<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><em><strong>\u201cEnforce pin and peripheral configuration at compile time. Guarantee that resources won\u2019t be used by unintended parts of your application.\u201c<\/strong><\/em><\/p>\n<p>Powerful static analysis is a point that sounds good to me. Coming from the Linux and GCC world, an actual \u201cgood\u201c static analysis would have been a big plus for a programming language some years ago. Today, the embedded (Linux) world is a bit more sophisticated. Since LLVM and clang caught up in this field, GCC is no longer the hardly avoidable tool of choice for embedded (Linux) systems with not-so-popular architectures. And with them, pretty good tools, in particular for static analysis entered the field. Even Linux, the once GCC-only operating system, is nowadays compilable with clang and benefits a lot from the clang static analyzer.<\/p>\n<p><span style=\"font-weight: 400;\">So let us get into the details and check if Rust can keep up with the Clang static analyzer and what is behind the catching sentence \u201cEnforce pin and peripheral configuration at compile time\u201c. The <\/span><i><span style=\"font-weight: 400;\">more details<\/span><\/i><span style=\"font-weight: 400;\"> button leads to the chapter on static guarantees in the <\/span><i><span style=\"font-weight: 400;\">Embedded Rust Book<\/span><\/i><span style=\"font-weight: 400;\">. It speaks from Rust as a strongly typed language. That is nice but nothing completely new \u2013 looking at C and C++, for example.\u00a0 They have strongly typed languages as well, even if they are not as strong as Rust is since it is (especially in C) rather easy to trick their typesystem.\u00a0<\/span><\/p>\n<p>This is followed by the example that Rust could statically check peripheral and similar configurations using its type system. That fact sounds more promising as a strong argument for Rust \u2013 but how is it done? While I was reading the shiny advertisement text, I hoped for a sophisticated mechanism that is somehow able to detect which pins (or similar peripherals) are used and if they are properly configured. But such an advanced feature remains a dream.<\/p>\n<p>In the following pages, the Rust embedded team presents a programming concept that takes advantage of the language\u2019s strong type system, which is not only useful for defining GPIO and similar peripheral APIs but in other contexts as well. The basic idea behind it is using empty structs as state representation and designing the peripherals in the API as state machines. The empty structures do not cost any memory at runtime but work as strong types which do not allow casts. This enables designing an API or contract in Rust speak which enforces the correct sequence for a peripheral using these states. For a better understanding, read\u00a0<a href=\"https:\/\/docs.rust-embedded.org\/book\/static-guarantees\/design-contracts.html#type-states\" target=\"_blank\" rel=\"noopener\">here<\/a>\u00a0on how this concept is intended.<\/p>\n<p>That is indeed a clever concept, but it is also a concept that is neither enforced for embedded Rust nor unique to this language. An equivalent solution would be realizable in e.g. C++, too. My colleague Florian did an example implementation for me in modern C++, as you can see <a href=\"https:\/\/github.com\/inovex\/blog-cpptypestates\" target=\"_blank\" rel=\"noopener\">here<\/a>. It is nice, clean and the example is more complete than the one on the Rust page.<\/p>\n<p>In the end, the nice and catchy advertising promise on the website collapses a little bit upon itself after a closer look. I wonder why they did not advertise their nice compiler and its features more instead of this concept.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Flexible-memory\"><\/span>Flexible memory<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><em><strong>\u201cDynamic memory allocation is optional. Use a global allocator and dynamic data structures. Or leave out the heap altogether and statically allocate everything.\u201c<\/strong><\/em><\/p>\n<p>When speaking about memory in embedded Rust, we need to differentiate between target platforms with the Rust standard library available and those without. Mostly, this will result in the question of whether it is needed to run in a bare metal environment or on top of an operating system. The marketing sentence on the embedded Rust website targets bare metal environments without the standard library. From my point of view, it is nevertheless needed to look at both cases, even when using embedded, as there is not necessarily a need for bare metal programming, depending on the problem to solve.<\/p>\n<p>Going without dynamic memory allocations at all bypasses, of course, has a lot of issues but it is neither possible, depending on the use case, nor a selling feature. Instead, I would wish the same safety Rust provides, e.g. for collections on bare metal (that means platforms without the standard library). Besides, it is a bit sad that bare metal programming with Rust relies on a no-std environment. But the C\/C++ world also has barely any libraries to use, so it is not better or worse.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Fearless-concurrency\"><\/span>Fearless concurrency<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><em><strong>\u201cRust makes it impossible to accidentally share state between threads. Use any concurrency approach you like and you\u2019ll still get Rust\u2019s strong guarantees\u201c<\/strong><\/em><\/p>\n<p>In general, Rust suffers from the same issues with concurrency as any other language does. For embedded software contexts, this includes:<\/p>\n<ul>\n<li>common multithreading,<\/li>\n<li>multi-core processors and<\/li>\n<\/ul>\n<ul>\n<li>dealing with interrupt handlers and interruptible code.<\/li>\n<\/ul>\n<p>Multithreading means having a single processor which swaps between the executed programs and\/or parts of them, e.g. the same processor executes the main program and a worker thread simultaneously via a time-sharing model. Shared data or states must not be compromised. Multi-core processors put this to the next level as both parts could run exactly at the same time on distinct processors, sharing memory and possibly caches.<\/p>\n<p>These issues are not limited to the embedded world but at least the third variant is more commonly used within the operating system and device drivers, while it is conceptually very similar to the others. When, for example, a peripheral button is pressed, immediate action is usually needed. When running the application in a loop, there is a chance the incoming signal is gone until the execution flow is on the handling code or it just takes more time than it should. Instead, interrupts and interrupt handlers are used. When they share states or data with the main application, we run into the same, known concurrency issues.<\/p>\n<p>The ways to handle these issues are in general very much the same as known from other programming languages. The first one is not allowing any kind of concurrency and thus interrupts at all. This might be a solution for very limited tasks on microcontrollers but more complex applications need to allow interrupts. For example, an application that implements an emergency stop for a machine needs to stop immediately. There is no time for looping through the code. When both parts, the main program, and the interrupt handler, now access an unprotected state variable, maybe even on a multiprocessor system at the same time, the feared concurrency issues could happen.<\/p>\n<p><span style=\"font-weight: 400;\">To sum it up, Rust does not only suffer from the same concurrency issues as other languages do, it offers the same set of mechanisms to cope with them as well. The most basic mechanisms are, among others, defining <\/span><i><span style=\"font-weight: 400;\">critical sections<\/span><\/i><span style=\"font-weight: 400;\"> by disabling interrupts, the use of <\/span><i><span style=\"font-weight: 400;\">atomic<\/span><\/i><span style=\"font-weight: 400;\"> data types, and the use of <\/span><i><span style=\"font-weight: 400;\">mutexes<\/span><\/i><span style=\"font-weight: 400;\">, which allows only one thread to execute a certain code region exclusively.\u00a0\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">And of course, Rust suffers from the same issues with them as well. Disabling interrupts directly, e.g. using <em>cortex_m::interrupt::free<\/em>, takes advantage of architectural-specific code and is rather not portable directly.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">These basic mechanisms do not prevent deadlocks. Additionally, mutexes and critical sections do not provide any safety at all on multiprocessor systems by design.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">More sophisticated and specific to (embedded) Rust is the idea behind how sharing peripherals is solved for device <\/span><i><span style=\"font-weight: 400;\">crates<\/span><\/i><span style=\"font-weight: 400;\"> (the Rust name for library) which were generated using <\/span><i><span style=\"font-weight: 400;\">svd2rust<\/span><\/i><span style=\"font-weight: 400;\">. This tool creates abstractions. That ensures the peripheral-representing structs can only exist once at a time. It is a nice idea but leads to some issues when it is needed to share the peripheral, e.g. in case it is needed in the main application and in an interrupt handler. For further information, read <a href=\"https:\/\/docs.rust-embedded.org\/book\/concurrency\/#sharing-peripherals\" target=\"_blank\" rel=\"noopener\">here<\/a><\/span><span style=\"font-weight: 400;\">.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Another attractive \u201cthird-party\u201c approach is using the <a href=\"https:\/\/docs.rust-embedded.org\/book\/concurrency\/#rtic\" target=\"_blank\" rel=\"noopener\">RTIC framework<\/a><\/span><span style=\"font-weight: 400;\">, which should not be discussed here in more detail.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">To summarize, Rust does not solve all the known concurrency issues in the low-level world via its language design. It offers mainly the same solutions as most languages do and adds some clever additional concepts. But it suffers from the same general pains. Its clever concepts could maybe minimize the pain with concurrency in some situations but are no global solution to avoid concurrency issues for all time. At least for low-level usage, Rust cannot make concurrency <\/span><i><span style=\"font-weight: 400;\">fearless <\/span><\/i><span style=\"font-weight: 400;\">(, yet).<\/span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"Portability\"><\/span>Portability<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><em><strong>\u201cWrite a library or driver once, and use it with a variety of systems, ranging from very small microcontrollers to powerful SBCs.\u201c<\/strong><\/em><\/p>\n<p><span style=\"font-weight: 400;\">Portability is indeed a big issue in embedded software. This reaches from general support for different architectures and platforms to related tools and toolchains like cross-compilers. These things were the ones I had in mind and wanted to learn more about when clicking the button.\u00a0 The link leads to the <\/span><i><span style=\"font-weight: 400;\">Embedded Rust Book<\/span><\/i><span style=\"font-weight: 400;\"> one more time, more explicitly to the <\/span><i><span style=\"font-weight: 400;\">Portability<\/span><\/i><span style=\"font-weight: 400;\"> chapter which tells me about the <\/span><i><span style=\"font-weight: 400;\">embedded-hal<\/span><\/i><span style=\"font-weight: 400;\">. Ok, hardware abstraction layers are a good idea in general as they introduce a layer between the actual hardware and software. But, as often mentioned in this article, this idea as well is neither new nor Rust-exclusive.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">In Rust, one central idea behind them seems to be reducing complexity and possible errors as they use the Hardware Abstraction Layer (HAL) to provide well-defined interfaces for central hardware components needed in embedded development, such as GPIO, Serial, I2C, SPI, Timers, and Analog-Digital Converters. As a result, the user does not need to know about how to implement these things on a specific device and it does not matter for which the software is written as the HAL specifies a well-defined interface while the implementation for specific hardware is done by others once. That is a nice approach that is used in many other places \u2013 especially in embedded development \u2013, but this does not answer the questions I had in mind when reading portability. To answer these questions, a little search leads to the <\/span><i><span style=\"font-weight: 400;\">rustc book <\/span><\/i><span style=\"font-weight: 400;\">and the <\/span><i><span style=\"font-weight: 400;\">rustup book<\/span><\/i><span style=\"font-weight: 400;\"> (The Rust people seem to like spreading their documentation as a set of <\/span><i><span style=\"font-weight: 400;\">books <\/span><\/i><span style=\"font-weight: 400;\">\u2026). <a href=\"https:\/\/doc.rust-lang.org\/nightly\/rustc\/platform-support.html\" target=\"_blank\" rel=\"noopener\">The rustc book<\/a><\/span><span style=\"font-weight: 400;\">\u00a0lists all currently available platforms and architectures subdivided into three tiers, where Tier 1 means <\/span><i><span style=\"font-weight: 400;\">guaranteed to work<\/span><\/i><span style=\"font-weight: 400;\">, Tier 2 means <\/span><i><span style=\"font-weight: 400;\">guaranteed to build,<\/span><\/i><span style=\"font-weight: 400;\"> and Tier 3 means <\/span><i><span style=\"font-weight: 400;\">not officially supported at all<\/span><\/i><span style=\"font-weight: 400;\">. When thinking about embedded devices as mostly single board computers or microcontrollers on an ARM basis in different levels, it is a bit annoying that only ARM64 with Linux is supported in the Tier 1 level (since 31.12.2020), while most other valid targets are located in Tier 2 or even Tier 3. That is not the best prerequisite for building safe and reliable embedded or IoT devices. The <\/span><i><span style=\"font-weight: 400;\">rustup book<\/span><\/i>\u00a0answers the remaining questions in <a href=\"https:\/\/rust-lang.github.io\/rustup\/cross-compilation.html\" target=\"_blank\" rel=\"noopener\">regards to cross-compiling<\/a>. rustup is an officially supported toolchain multiplexer that is intended to bring the needed rustc compiler and standard libraries for possible target platforms. It is a nice idea to bundle toolchains for cross-compiling in a central, well-maintained tool to avoid a mess like known from different Linux toolchains for ARM. Unfortunately, this idea is still not yet ready, too. For example, additional, necessary tools to cross-compile for another target like a particular linker must be installed manually. And that brings the potential of a mess as well.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Community-driven\"><\/span>Community-driven<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><em><strong>\u201cAs part of the Rust open source project, support for embedded systems is driven by a best-in-class open source community with support from commercial partners.\u201c<\/strong><\/em><\/p>\n<p>When thinking about this point and its description, I felt at first a bit like \u201cOk, cool, but what\u2019s your point?\u201c, especially when I clicked the read more button and found myself on the GitHub repository of the Rust-embedded Working Group. Thus, I am still not sure what to think about the emphasis on Rust being community-driven. But it gets me to a very relevant and important point: licensing. The Rust programming language and officially related projects are dual-licensed with the Apache 2.0\u00a0 and the MIT license. These are very permissive licenses that allow the use of Rust in commercial applications, while it is not needed to disclose the source code. This would enable the use of Rust in most projects.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"Interoperability\"><\/span>Interoperability<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><em><strong>\u201cIntegrate Rust into your existing C codebase or leverage an existing SDK to write a Rust application.\u201c<\/strong><\/em><\/p>\n<p>Combining current applications with Rust and swapping suitable parts out to take advantage of Rust\u2019s features sounds like a perfect plan to get started and slowly move to Rust when it offers a benefit. According to the Rust embedded book, this is also possible vice versa.<\/p>\n<p>It would be nicer if this interoperability would be a core feature of Rust and thus available on no_std environments out-of-the-box, but as the functionality is generally available, it is just a minor pain point. Another pain point is the dependence on the Cargo build system. It seems this use case is currently not that widespread and thus rather poorly documented in contrast to other issues of Rust in an embedded environment.<\/p>\n<p>But in general, this interoperability is a very promising starting point for the use of Rust in embedded. Even if Rust is no magic bullet that makes code generally errorless and great all time, it is still a promising language and has the potential to make embedded applications less error-prone using its language features. The option to combine already existing C or C++ code with Rust offers a way to migrate step-by-step, e.g. by putting a (maybe rather high-level) new feature or functionality into a Rust library. This could enable teams to get in contact with the language in a real-world scenario without a huge risk and evaluate it for their exact use case.<\/p>\n<h2><span class=\"ez-toc-section\" id=\"And-in-the-end\"><\/span>And in the end?<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>When I started this blog post, I did it because the Rust programming language seems to be the rising star in systems and embedded programming. Rust is on its way into Linux which is remarkable since there was not a serious discussion on Linux drivers in any other language, yet. Additionally, Google started to put more and more into the Android (AOSP) tree. So I started playing around with Rust, read a lot, and found that shiny landing page on Embedded Rust.<\/p>\n<p>When reading my results from this deep dive above, one could think Rust is not (yet) suitable at all or a poorly designed language. But that is not the case. Rust is still a very interesting and promising language! But at least for hardcore embedded usage, mostly for bare metal programming, it is just not as far developed as this shiny little embedded landing page suggests. This does not make the whole language bad, even if it is right that Rust is sometimes rather hard to learn and academic.<\/p>\n<p>Looking at the current state, I could not imagine starting a bare-metal project using Rust. There are several reasons for it and the general stability of the language is one major issue.\u00a0 Incompatible changes between major releases result in a high effort to keep the code up to date. Otherwise one must accept it may not compile anymore after a rather short time. This is unacceptable for most commercial projects, but I think a system library within the AOSP could be fine right now. As big companies like Google have time and money to keep up with the development (I forget python 2 which is still all over the AOSP tree for the moment).<\/p>\n<p>However, when considering that the first stable version is only 6 years old, it is probably completely fine to give Rust some more years to become that nice language in the (admittedly difficult and heterogeneous) embedded environment as the shiny landing page already suggests today.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.<\/p>\n","protected":false},"author":35,"featured_media":34561,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"ep_exclude_from_search":false,"footnotes":""},"tags":[377],"service":[505],"coauthors":[{"id":35,"display_name":"Anna-Lena Marx","user_nicename":"amarx"}],"class_list":["post-34291","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","tag-development","service-embedded-systems"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.5 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Rust for Embedded - Is It Ready Yet? - inovex GmbH<\/title>\n<meta name=\"description\" content=\"Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Rust for Embedded - Is It Ready Yet? - inovex GmbH\" \/>\n<meta property=\"og:description\" content=\"Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\" \/>\n<meta property=\"og:site_name\" content=\"inovex GmbH\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/inovexde\" \/>\n<meta property=\"article:published_time\" content=\"2022-02-09T10:03:28+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-11-21T14:39:46+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1920\" \/>\n\t<meta property=\"og:image:height\" content=\"1080\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Anna-Lena Marx\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust-1024x576.png\" \/>\n<meta name=\"twitter:creator\" content=\"@inovexgmbh\" \/>\n<meta name=\"twitter:site\" content=\"@inovexgmbh\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Anna-Lena Marx\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"16\u00a0Minuten\" \/>\n\t<meta name=\"twitter:label3\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data3\" content=\"Anna-Lena Marx\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\"},\"author\":{\"name\":\"Anna-Lena Marx\",\"@id\":\"https:\/\/www.inovex.de\/de\/#\/schema\/person\/b7d6fd8c3ec8972f3b14f0205e25d022\"},\"headline\":\"Rust for Embedded &#8211; Is It Ready Yet?\",\"datePublished\":\"2022-02-09T10:03:28+00:00\",\"dateModified\":\"2022-11-21T14:39:46+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\"},\"wordCount\":2760,\"commentCount\":12,\"publisher\":{\"@id\":\"https:\/\/www.inovex.de\/de\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png\",\"keywords\":[\"Development\"],\"articleSection\":[\"Analytics\",\"Applications\",\"English Content\",\"General\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\",\"url\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\",\"name\":\"Rust for Embedded - Is It Ready Yet? - inovex GmbH\",\"isPartOf\":{\"@id\":\"https:\/\/www.inovex.de\/de\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png\",\"datePublished\":\"2022-02-09T10:03:28+00:00\",\"dateModified\":\"2022-11-21T14:39:46+00:00\",\"description\":\"Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage\",\"url\":\"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png\",\"contentUrl\":\"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png\",\"width\":1920,\"height\":1080,\"caption\":\"Grafik: Frau steht neben gro\u00dfem Fragezeichen und Rust Logo\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.inovex.de\/de\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Rust for Embedded &#8211; Is It Ready Yet?\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.inovex.de\/de\/#website\",\"url\":\"https:\/\/www.inovex.de\/de\/\",\"name\":\"inovex GmbH\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/www.inovex.de\/de\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.inovex.de\/de\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.inovex.de\/de\/#organization\",\"name\":\"inovex GmbH\",\"url\":\"https:\/\/www.inovex.de\/de\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/www.inovex.de\/de\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.inovex.de\/wp-content\/uploads\/2021\/03\/inovex-logo-16-9-1.png\",\"contentUrl\":\"https:\/\/www.inovex.de\/wp-content\/uploads\/2021\/03\/inovex-logo-16-9-1.png\",\"width\":1921,\"height\":1081,\"caption\":\"inovex GmbH\"},\"image\":{\"@id\":\"https:\/\/www.inovex.de\/de\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/inovexde\",\"https:\/\/x.com\/inovexgmbh\",\"https:\/\/www.instagram.com\/inovexlife\/\",\"https:\/\/www.linkedin.com\/company\/inovex\",\"https:\/\/www.youtube.com\/channel\/UC7r66GT14hROB_RQsQBAQUQ\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.inovex.de\/de\/#\/schema\/person\/b7d6fd8c3ec8972f3b14f0205e25d022\",\"name\":\"Anna-Lena Marx\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/www.inovex.de\/de\/#\/schema\/person\/image\/a8cfb531252ec2ef604ef3033c45111b\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/44ab0d3916e62a17054b8e4cea92702db304b9dcb6dd28fb9915484c1830409b?s=96&d=retro&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/44ab0d3916e62a17054b8e4cea92702db304b9dcb6dd28fb9915484c1830409b?s=96&d=retro&r=g\",\"caption\":\"Anna-Lena Marx\"},\"url\":\"https:\/\/www.inovex.de\/de\/blog\/author\/amarx\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Rust for Embedded - Is It Ready Yet? - inovex GmbH","description":"Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/","og_locale":"de_DE","og_type":"article","og_title":"Rust for Embedded - Is It Ready Yet? - inovex GmbH","og_description":"Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.","og_url":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/","og_site_name":"inovex GmbH","article_publisher":"https:\/\/www.facebook.com\/inovexde","article_published_time":"2022-02-09T10:03:28+00:00","article_modified_time":"2022-11-21T14:39:46+00:00","og_image":[{"width":1920,"height":1080,"url":"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png","type":"image\/png"}],"author":"Anna-Lena Marx","twitter_card":"summary_large_image","twitter_image":"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust-1024x576.png","twitter_creator":"@inovexgmbh","twitter_site":"@inovexgmbh","twitter_misc":{"Verfasst von":"Anna-Lena Marx","Gesch\u00e4tzte Lesezeit":"16\u00a0Minuten","Written by":"Anna-Lena Marx"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#article","isPartOf":{"@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/"},"author":{"name":"Anna-Lena Marx","@id":"https:\/\/www.inovex.de\/de\/#\/schema\/person\/b7d6fd8c3ec8972f3b14f0205e25d022"},"headline":"Rust for Embedded &#8211; Is It Ready Yet?","datePublished":"2022-02-09T10:03:28+00:00","dateModified":"2022-11-21T14:39:46+00:00","mainEntityOfPage":{"@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/"},"wordCount":2760,"commentCount":12,"publisher":{"@id":"https:\/\/www.inovex.de\/de\/#organization"},"image":{"@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage"},"thumbnailUrl":"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png","keywords":["Development"],"articleSection":["Analytics","Applications","English Content","General"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/","url":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/","name":"Rust for Embedded - Is It Ready Yet? - inovex GmbH","isPartOf":{"@id":"https:\/\/www.inovex.de\/de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage"},"image":{"@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage"},"thumbnailUrl":"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png","datePublished":"2022-02-09T10:03:28+00:00","dateModified":"2022-11-21T14:39:46+00:00","description":"Does Rust keep what its developers promise for programming embedded devices? This article examines their claims and whether they can keep their promises.","breadcrumb":{"@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#primaryimage","url":"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png","contentUrl":"https:\/\/www.inovex.de\/wp-content\/uploads\/Rust.png","width":1920,"height":1080,"caption":"Grafik: Frau steht neben gro\u00dfem Fragezeichen und Rust Logo"},{"@type":"BreadcrumbList","@id":"https:\/\/www.inovex.de\/de\/blog\/rust-for-embedded-is-it-ready-yet\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.inovex.de\/de\/"},{"@type":"ListItem","position":2,"name":"Rust for Embedded &#8211; Is It Ready Yet?"}]},{"@type":"WebSite","@id":"https:\/\/www.inovex.de\/de\/#website","url":"https:\/\/www.inovex.de\/de\/","name":"inovex GmbH","description":"","publisher":{"@id":"https:\/\/www.inovex.de\/de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.inovex.de\/de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/www.inovex.de\/de\/#organization","name":"inovex GmbH","url":"https:\/\/www.inovex.de\/de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.inovex.de\/de\/#\/schema\/logo\/image\/","url":"https:\/\/www.inovex.de\/wp-content\/uploads\/2021\/03\/inovex-logo-16-9-1.png","contentUrl":"https:\/\/www.inovex.de\/wp-content\/uploads\/2021\/03\/inovex-logo-16-9-1.png","width":1921,"height":1081,"caption":"inovex GmbH"},"image":{"@id":"https:\/\/www.inovex.de\/de\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/inovexde","https:\/\/x.com\/inovexgmbh","https:\/\/www.instagram.com\/inovexlife\/","https:\/\/www.linkedin.com\/company\/inovex","https:\/\/www.youtube.com\/channel\/UC7r66GT14hROB_RQsQBAQUQ"]},{"@type":"Person","@id":"https:\/\/www.inovex.de\/de\/#\/schema\/person\/b7d6fd8c3ec8972f3b14f0205e25d022","name":"Anna-Lena Marx","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.inovex.de\/de\/#\/schema\/person\/image\/a8cfb531252ec2ef604ef3033c45111b","url":"https:\/\/secure.gravatar.com\/avatar\/44ab0d3916e62a17054b8e4cea92702db304b9dcb6dd28fb9915484c1830409b?s=96&d=retro&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/44ab0d3916e62a17054b8e4cea92702db304b9dcb6dd28fb9915484c1830409b?s=96&d=retro&r=g","caption":"Anna-Lena Marx"},"url":"https:\/\/www.inovex.de\/de\/blog\/author\/amarx\/"}]}},"_links":{"self":[{"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/posts\/34291","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/users\/35"}],"replies":[{"embeddable":true,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/comments?post=34291"}],"version-history":[{"count":5,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/posts\/34291\/revisions"}],"predecessor-version":[{"id":34598,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/posts\/34291\/revisions\/34598"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/media\/34561"}],"wp:attachment":[{"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/media?parent=34291"}],"wp:term":[{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/tags?post=34291"},{"taxonomy":"service","embeddable":true,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/service?post=34291"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.inovex.de\/de\/wp-json\/wp\/v2\/coauthors?post=34291"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}