Today we like to reflect on our progress and share our plans for the future of Fe. In December 2022 Fe hit the Ethereum mainnet for the very first time with the deployment of our bug bounty contest. Although it was hacked shortly after, no serious issues were revealed. The initial hack was just a sloppy fat-finger-copy-and-paste issue on our end but we invite you to read the inside story from the bounty hunter's perspective because it's such a great read.

If you've been following our recent updates, you will know that we quickly fixed the issue and restarted the contest and that the ongoing bug bounty contest did not reveal any critical bugs. In fact, the bounty is still up for grabs, go check it out if you're interested.

This certainly doesn't mean that Fe is bug-free, quite the contrary, we expect the compiler to still have bugs and we want to invite you to find and report them. It also doesn't mean that it's a polished language yet. We are still missing important features and have to iron out rough edges.

However, it does mean that we are confident enough to drop the -alpha marker from releases, starting with the latest 0.22.0 release. As we've mentioned in the past, dropping the -alpha marker does not imply that the language is stable or feature-complete. It will still take a long way to go before we get anywhere close to that. As we continue to follow semantic versioning our 0.x releases continue to be unstable.

A bright future

In fact, we are currently in the process of rewriting large parts of the Fe compiler. This is necessary because the existing code base is not well suited for the features we want to add in the future. When the current rewrite is finished it will enable more advanced features such as:

• Enhanced support for generics (e.g. generic structs, generic traits, multiple trait bounds, etc.)
• Improved trait support (e.g. trait inheritance, trait specialization, etc.)
• Const functions (Functions that can run at compile time rather than at runtime)
• Type inference
• Flexible abstraction on ABI encoding/decoding
• Support for Language Server Protocol (LSP)

Additionally, we're working to replace Fe's Solidity backend. Fe currently uses YUL as its intermediate language and relies on the Solidity compiler to convert YUL to EVM bytecode. We're developing a native LLVM-inspired backend called Sonatina, which will replace this dependency, allowing for more aggressive optimizations and a streamlined Rust-only compilation process.

In conclusion, we're thrilled with the progress Fe has made and are confident that the upcoming improvements will further enhance the language. We invite you to join us in exploring and experimenting with Fe as it continues to mature. Your feedback and contributions are invaluable as we work together to build a robust, feature-rich programming language.

Thank you for your support, and stay tuned for more exciting developments!