Five years and counting!

Today we celebrate the 5^th anniversary of .NET nanoFramework. This is more like an ongoing celebration because the initial work on the project started in August 2016 and our stable version 1.0 was published 3 years ago on this day. 

As part of the celebrations, we are announcing a new logo for the project. It’s meant to be a refresh on the image, convey a more modern look and pass a message on the project’s vitality. 

Looking back at the past 12 months we’ve accomplished a lot! Let’s go through all that with some detail. 

• Unit Test framework was released. With this we gave a huge step forward in the tools we provide to help developers increase their QA. This allows them to use a test framework they are familiar with and that’s part of Visual Studio, just like the full .NET framework. 
• Logging framework based on Microsoft.Extensions.Logging. Another big helper for developers and, again, using an API with which .NET developers are familiar with. 
• Azure IoT SDK. We have an SDK for Azure IoT, aligned (as much as possible) with the one of the full .NET. Has support for Device Provisioning Service, Digital Twins and, of course, sending and receiving messages with MQTT. 
• AWS IoT SDK. We’ve recently added an SDK to connect to Amazon Web Services. Still in early stages but already covering a lot of the available features.
• IoT device bindings. A lot (and I really mean a LOT) of work has been done on migrating the IoT device bindings from .NET IoT and on improving them. It’s amazing the amount of of devices that are available and the quality of them. Big thanks for all the developers that have been involved on this ongoing effort. 
• Units.NET made available. This is a very neat and powerful library that’s extremely helpful when one has to deal with units. Work was done to have a significant part of the library ported to .NET nanoFramework and for several months now, NuGet packages for these are available. 
• Developer containers. Being able to build the firmware image for nanoCLR locally it’s something that requires setting up the build toolchain. Because this was considered a hard task and was always causing some pain among the developers that wanted to do it, we decided to provide Docker Containers with the toolchain and all required tools installed and ready to use. With this, anyone can now happily build at the comfort of their machine, the firmware for nanoCLR ready to flash on the various devices. 
• Migration to System.Device namespace. From the beginning of the project, we were following the UWP API with the various Windows.Devices namespaces. During the past year and we a closer cooperation and effort on aligning APIs with .NET IoT, work was started to move all those to System.Device. A lot of effort was made to align the APIs so that code reuse was possible without much (or very little) effort from developers. This is now a mission accomplished and we are waiting for a couple more stable releases to drop entirely the Windows.Devices libraries. 
• Move to ESP-IDF 4.3.1. This is a huge one and it was long due! Was pulled off just last week. Our builds for ESP32 targets are now using the latest Espressif ESP-IDF. Because of the serious rework done in our build system to accommodate and seamlessly integrate with ESP-IDF build system, we are now able to follow their releases. Not only that, but this allows now to have support for all the other series ESP32_S2, ESP32_S3 and ESP32_C3. 
• .NET nanoFramework now has its own official TFM. This too was an awesome accomplishment! Through the .NET Foundation we were able to connect with the .NET and NuGet teams and work was made to have NuGet CLI to support our project system. Immediate benefit was that anyone can now use nuget CLI with .NET nanoFramework projects just like with any other .NET project. Ongoing effort is to extend this to be able to use SDK style projects. 
• Improvements in debugger library and Visual Studio experience. This is one of those that lives deep under the hood, everyone uses daily and doesn’t even notice that’s there. Up to a few months ago the debugger library was using the UWP USB API to connect to nano devices. This was a serious draw back in having support for other development platforms (Unix and MacOS) and was tying us to UWP components which, in turn, don’t get along that well with Visual Studio extensibility, which is required for our extension and, ultimately, to code for our nano devices. Work was done to migrate the communication layer to .NET System.IO.Ports namespace. With this we are now aligned with the .NET framework, we can have (which we already have) multi-platform deployment and we are future proof ready for changes in Visual Studio extensibility. In the process several improvements and tweaks were made to improve the stability and performance of the communication from Visual Studio with the nano devices. 
• Network improvements. On this front the most relevant improvements are related with the fact that one can now store on persistent storage a CA root bundle certificate but also device X509 certificates. This improves immensely usage scenarios that require a device certificate for authentication with connected services like Azure IoT and AWS IoT. On this front too we keep mbedTLS (our TLS provider) up to date with the latest and greatest version to keep our nano devices safe and secure, as far as network is concerned.  
• Documentation improvements. Another front which has seen vast improvements during the past year. These include not only the amount of documentation made available, but also the quality of it, it’s accuracy and overall quality, the organization of it and automation on all this is handled. This last bit may seem less relevant but let me assure it’s not. Being the project staffed by a small team, we need to make sure we can be as efficient as possible, so everyone can focus on the relevant matters and not on routine and maintenance tasks. 
• Repository renaming. This was more than just a cosmetic change. The repositories for the various class libraries were renamed to be in line with the .NET namespaces. Hopefully this helps developers recognize the alignment of the APIs and give a sense of familiarity. 
• A ton of tiny (and not so tiny) improvements at the native code. These are, again, mostly not noticeable but that makes a difference on how the firmware behaves, on how smooth things run and performance gains that can be achieved. We are always working on these and the past year is no exception. If you have any doubts, please check the number of PRs and associated commits in the nf-interpreter repository that where closed during the last year alone. 
• The community involvement has significantly grown. We have now over 1500 members on Discord. The traffic there has increased significantly. The number of questions asked (and promptly replied) as grown too. The number of PRs with fixes and new features has noticeably increased. All these are signs of the project’s vitality, increased maturity and awareness from the public. 

Well… we’re all excited (and I’m personally very, very happy and proud) about all that was accomplished. But more important, we renew our commitment on empowering more people and more organizations to achieve more by bringing the power of .NET C# to resource constrained micro-controllers. 

“Long live and prosper” .NET nanoFramework!  🙂