EVCS is leading the automotive electrification revolution with one of the fastest growing networks of level 2 and DC Fast charging points in California, Oregon and Washington

EVCS

evcs

ZKP Meets ML in Verifiability: Existing Scheme & Experimental Analysis

This example project has everything you need to localize your native Android application on platform, using a fully automated approach. Smartcat continuous localization See >>> bootstrap project at github What we offer here is a pre-configured Docker container with our command-line localization automation tool, , which will pull the changes from your code repository, parse the source file, send translation data over to Smartcat, get translations back, integrate them into its local database, generate localized files and push them back to your repo, all in a single sweep. Serge (String Extraction and Resource Generation Engine) strings.xml This approach to localization: Doesn't require writing custom low-level integration code: you write declarative configuration files instead Doesn't require you to change your CI/CD build process: translations are integrated statically into your source code repository Is secure: you don't give Smartcat direct access to your source code repositories, and you control all the synchronization Is vendor lock-in free: you own your translation data, and can generate localized resource files completely offline Is flexible: you can manually run it on your computer, or run it on a schedule on a dedicated host Is powerful: you can implement localization workflows that otherwise would require many months of development (see below). Features With our continuous localization solution, you have an unprecedented flexibility and power. Some ideas that might inspire you are: Automatic discovery and localization of multiple product branches Ability to prohibit localized file updates unless they are 100% translated (handy for marketing materials!) Ability to specify target languages right in each file, to enable automated self-service scenarios Pseudo-localization for easier internationalization (i18n) QA Conditional exclusion of certain strings by mask Ability to auto-generate comments and preview links for each string Ability to group multiple repositories and different file types under a same logical project Ability to preprocess source files for greater flexibility Ability to post-process localized files so that the final result is CI/CD-ready Ability to email developers if source files are broken ... and much more! Installation 1. for your Windows, Mac, or Linux. Install Docker 2. Run this command to install Serge for the first time, or to update it to a latest version: $ docker pull smartcatcom/serge 3. Clone this repository into any directory: $ git clone https: //github.com/smartcatai/smartcat-serge-bootstrap-android-native.git 4. Create an account at Smartcat. 5. Create a new project in Smartcat to synchronize your data with, with as a source and and as target languages (don't worry, you will be able to change the settings later). English German Russian Getting Started Running Serge in interactive mode In the root directory of this repo we have provided you a convenience script to run a Serge shell, from which you will have access to command. Run it as follows (both under Windows, Mac or Linux): serge $ ./serge-shell When you enter your shell, the root directory of your bootstrap project will be mounted as / and you will see the following prompt: data [Serge Shell] /data $ Here and below, it is assumed that you're running the commands inside this shell. At the same time, you can continue editing the configuration files or browse the directory outside of the shell in Explorer, Finder, or any other favorite file management tool and code editor. Note: Now you that you are inside this interactive shell, you can run Serge (the command below will just show some short usage synopsis and a list of available commands): $ serge To exit the shell later, use the command: exit $ exit Getting around This repository contains a sample project, . First things to do are: android-native See the configuration file: configs/android-native.serge Look at the contents of the source project folder: vcs/android-native This sample project is set up to have (English) as a source language and (German) and (Russian) as target languages, and will process all keys in the resource file in directory. en de ru strings.xml vcs/android-native/src/main/res/values Initial run Go to the directory and run the localization step: configs $ cd configs
$ serge localize This will create localized files under and directories. These files will have English content, since translations have not been provided just yet. vcs/android-native/de vcs/android-native/ru The same localization step will generate translation files under and directories. You can examine the generated files and also see their initial state with no translations. ts/android-native/de ts/android-native/ru .po Doing translations locally Edit e.g. file and provide a translation for a single string (for testing purposes, any random "translation" will work). ts/android-native/de/strings.xml.po Run once again from the directory. If you now open the localized resource file, e.g. , you will see that your translation has been integrated into the XML file. serge localize configs vcs/android-native/src/main/res/values-de/strings.xml Connecting with Smartcat Create a new project in Smartcat with as a source language and and as target ones. Languages must be registered on the project before you can upload files targeting those languages. You can later change the list of target languages at any time. English German Russian Edit the file and fill out your account parameters and credentials under config section: , , and . Instructions next to each parameter will help you understand where to get the values from. Once defined, these settings will be shared across your future localization projects. configs/common.serge.inc common-settings → ts base_url account_id token Edit the file and specify the , following the instructions in the configuration file. configs/android-native.serge project_id Now you can push your translation files to Smartcat: $ serge push-ts Go to Smartcat, open the test project you created, and there you will see your and files available for translation, one for German, and another one for Russian. strings.xml_de strings.xml_ru Open e.g. and edit the translation for the string that you translated previously. strings.xml_de Now you can pull translations from Smartcat and run a localization cycle at once: $ serge pull-ts localize If you now open the localized resource file, , you will see that the new translation has been integrated into the XML file. vcs/android-native/src/main/res/values-de/strings.xml Running the localization continuously This project has two convenience scripts, and that you can use as a starting point for your continuous localization process. sync-once.sh sync-loop.sh Run to run the sync/localization cycle just once. ./sync-once.sh Run to run the sync/localization cycle every 5 minutes. You can edit the file and put any delay you want. ./sync-loop.sh While the localization is running in background (eventually you will want to run it on a dedicated server), you can modify your example project (add, change or delete keys in your source XML file) and provide translations on Smartcat side at the same time, and Serge will merge in all these changes, gathering the new translations, updating the localized resources, and pushing new strings for translation. Adding VCS synchronization The last missing step is to make Serge not only generate the localized files locally, but also pull the sources from your actual source code repository, and push localized files back to the remote repo. Since Git is the most popular version control system, this sample project includes a stub for connecting to a Git repo. Edit the file so that parameter points to the actual remote repository URL. Now initialize the data from the remote repo (this will remove the previous contents of folder with the contents of your repository): configs/android-native.serge → sync → vcs → data → remote_path vcs/android-native $ serge pull --initialize android-native.serge The parameter in this command is needed only once, when you want to delete and re-populate the contents of the project folder. --initialize Now your project has a different directory structure, and maybe different files (not JSON), so you need to edit your file accordingly (see , , parameters, and the section). At this point we recommend you to spend some time reading the for the list of available parsers and their parameters, and the . configs/android-native.serge → jobs → (first job section) → source_dir source_match output_file_path parser Serge documentation configuration file syntax and reference Once you have your job parameters tweaked, it's time to test this by running a localization cycle once again, and also cleaning up the outdated translation files: $ serge localize
$ serge clean-ts If you see that a set of localized files was properly created in your folder, and that translation files in folder also look good, you can push the localized files back to the remote repository: vcs/android-native ts/android-native $ serge push The last and final step is to enable the full synchronization cycle. Edit the script by disabling the line and enabling the line. The latter command is equivalent to . In human language, this means that running will do everything a continuous localization is expected to do: pull the new contents from both your Git server and Smartcat, update localized resources and translation files, and push changes back to Git and Smartcat, respectively. sync-once.sh serge pull-ts localize push-ts serge sync serge pull pull-ts localize push-ts push serge sync Finally, run: ./sync-loop.sh Congratulations! You now live in the world of smooth continuous localization . (press Ctrl+C anytime to get back to reality) Running Serge in a non-interactive mode When you don't need an interactive shell (especially when you're running Serge on a dedicated server), you can use a provided wrapper, as follows: run-in-docker $ ./run- -docker serge localize configs/android-native.serge in or: $ ./run- -docker ./sync-loop.sh in Adding new projects In the paradigm of continuous localization, your Smartcat projects will be permanent; content in these projects will be constantly updated, reflecting the changes in your repositories and external content sources. You can create one project for your iOS application, another one for Android, for your website, documentation, and so on. To set up a new project (besides creating one in Smartcat), you will need to make a copy of to (of course, file and project names are up to you), and edit a new configuration file accordingly. configs/android-native.serge configs/project-b.serge Getting professional support At Smartcat, we strive to build delightful localization processes that work seamlessly and don't slow you down. We offer managed solutions and localization engineering services , so you don't have to figure this out all by yourself! as a part of the subscription Previously published at https://github.com/smartcatai/smartcat-serge-bootstrap-android-native

How To Localize Your Android App: A Step by Step Guide

VCs, institutional investors and family offices descend on South Beach for the weeklong rave with Christo, Calvin Harris, Kaskade, Die Antwoord and Zedd If all of your crypto friends are racing down to Florida next week, it’s because world’s hippest art show, , is bringing together 77,000 fans, celebrities, collectors, institutional investors, family offices and venture capitalists for a week of epic partying and talks on decentralized art. Art Basel Miami There will be 4,000 artists from 268 galleries showcasing their works but the real story will unfold afterhours in popup nightclubs, elevators of the ultra chic hotels: , , , , , , , , , , , , and maybe, just maybe, Jeremy Gardner’s Crypto Castle Miami. Soho Beach House W South Beach Delano Miami Beach Edition Fontainebleau 1 Hotel Faena The Plymouth Freehand Sagamore SLS Brickell JW Marriott Marquis This year headliners announced include Calvin Harris, Kaskade, Die Antwoord, Action Bronson and Zedd! Last year, All Day I Dream/Lee Burridge, Bob Moses, Bjork, Chromeo, Claude von Stroke, Cut Copy, Diplo, Doug E Fresh & The Sugarhill Gang, Major Lazer, Markus Schulz, Paris Hilton, Rick Ross, Wu-Tang Clan, 2 Chainz, and 50 Cent performed. The Art Basel epicenter takes place December 5 through December 9 at the Miami Convention Center with satellite shows sprawling beyond which include Art Miami, Aqua Art Miami, CONTEXT Art Miami, The Directed Art Modern, INK Miami Art Fair, Faena Festival, Miami River Art Fair, NADA , PINTA, PRIZM Art Fair, PULSE, Red Dot Miami, SCOPE, Spectrum, Superfine! and UNTITLED. To get a sense of what Art Basel is like, check out by Florum Fashion. this 2017 pictorial review I’ll be on the scene speaking at the SCOPE Art Show on and tweeting all of the shenanigans . When Deals Turn Digital: New Technologies, Banking, and the Future of the Art Market @contentnow Here’s what’s on for crypto: Bass Museum, 2100 Collins, 33139 WHEN: Wednesday, December 5, 6–8pm/8–10pmWHAT: Bass Museum Opening Party featuring The Haas BrothersWHERE: HOW: https://thebass.org/event/member-reception-haas-brothers/ Soho Studios, 2136 NW 1st Avenue, Miami, FL, 33127 WHEN: Wednesday, December 5, 10pmWHAT: Die AntwoordWHERE: HOW: https://www.seetickets.us/event/DIE-ANTWOORD-at-Soho-Studios/373623 Lemon City Studios, 261 NE 73rd, 33138 WHEN: Wednesday, December 5, 11pmWHAT: ARIA with Guy Laliberte, Alex Neri: Maria Callas TributeWHERE: HOW: https://www.residentadvisor.net/events/1189938 disrupting a $64 billion marketplace. Featuring visual artist, .2–3pm Tokenizing Art with Forbes’ Rachel Wolfson and artists Jesselyn Contreras, Johnny Dollar, Carrie Eldridge and Rob Charles3:15–3:45pm Investors Panel with TheStreet’s Jordan French, Ausum Ventures’ Jeremy Gardner, Bluesky Capital’s Andrea Lecesse, Lex Capital’s Alex Mendoza, Kryptal Group’s Edna Yuan, Park Capital Partners’ Alexander Lopatine, Level 7’s Michael Blin, Crowdsmart.io VC’s Richard Swart. Nikki Beach, 1 Ocean Drive, Miami Beach, 33139 WHEN: Thursday, December 6, 9–6pm WHAT: Art Decentralized, The World of Distributed Masterpieces Vesa WHERE: HOW: https://www.eventbrite.com/e/art-decentralized-the-world-of-distributed-masterpieces-blockchain-art-registration-51810706217 Soho Studios, 2136 NW 1st Avenue, Miami, FL, 33127 WHEN: Thursday, December 6, 10pmWHAT: Action BronsonWHERE: HOW: https://www.seetickets.us/event/ACTION-BRONSON-at-Soho-Studios/373655 LIV Nightclub at Fontainebleau, 4441 Collins Avenue WHEN: Thursday, December 6, 11pm-5am WHAT: Zedd Basel Edition at LIV WHERE: HOW: https://www.tixr.com/groups/liv/events/zedd-basel-edition-11166 E11EVEN, 29 NE 11th Street WHEN: Thursday, December 6, 11pm-8amWHAT: G-Eazy Basel Edition at E11EVEN WHERE: HOW: https://www.tixr.com/groups/11miami/events/art-basel-g-eazy-11073 with Kiki Del Valle, SVP Digital Future, Mastercard Katya Fisher, Tech and Corporate Attorney, Fisher Catalotti Vanessa Grellet, Executive Director, Consensys Elena Zhavelev, Forbes contributor and Founder, New Art Academy, Martine Paris, Tech Reporter, The FinTech Times MasterCard Tent, 801 Ocean Drive, Miami Beach, 33139 WHEN: Friday, December 7, 10–12pm WHAT: SCOPE Art Show presented by MasterCard, When Deals Turn Digital: New Technologies, Banking, and the Future of the Art Market WHERE: HOW: https://scope-art.com/show/miami-beach-2018/programming , Christo best known for massive environmental installations like the Umbrellas in California and Japan, the Wrapped Reichstag in Berlin and the Floating Piers in Lake Iseo, Italy will talk about Miami Beach Convention Center, Auditorium, West Lobby, 1901 Convention Center Drive, Miami Beach 33139 FREE, open to the public, or watch live: , WHEN: Friday, December 7, 10–11:30am WHAT: Artist Talk - Christo, Tomás Saraceno, and Hans Ulrich Obrist WHERE: HOW: facebook.com/artbasel https://www.artbasel.com/events/detail/7854/Conversations-Artist-Talk-Artists-Influencers with Ruth Catlow, Furtherfield/DECL London, Matt Hall, Cryptopunks New York, Harm van den Dorpel, Artist, Berlin, and Orit Gat, Writer, New York, London — What are the social and political implications of decentralized financial networks? Is blockchain a reliable source for fundraising? How are artists using it in their artistic practice? Miami Beach Convention Center, Auditorium, West Lobby, 1901 Convention Center Drive, Miami Beach 33139 FREE, open to the public, or watch live: WHEN: Friday, December 7, 2:30–3:30pm WHAT: Art Market Talk — Which Art Problems Can Blockchain Solve? WHERE: HOW: facebook.com/artbasel **WHEN: Friday, December 7, 4:30–5pmWHAT: Brian Kelly, CNBC’s Fast Money Keynote at CryptoProExpo**This conference provides a market update and fundamentals, how to set up a crypto fund, how to identify blockchain investment opportunities including STOs, and the intersection of art, crypto and blockchain Fontainebleau WHERE: HOW: https://cryptoproexpo.com/miami-art-week-2018 Foxhole, 1218 14th Court, Miami Beach 33139 WHEN: Friday, December 7, 9pm–5amWHAT: DJ Jazzy Jeff WHERE: HOW: https://www.eventbrite.com/e/jazzy-jeff-at-foxhole-bar-art-basel-2018-tickets-52617016914 Basement at Miami Beach EDITION Hotel, 2901 Collins Avenue In List App WHEN: Friday, December 7, 10pm–5amWHAT: Saint Vie + Coss + Mateo WHERE: HOW: Historic Virginia Key Beach WHEN: Saturday, December 8, 3pm-7amWHAT: Rakastella feat Dixon + DJ Tennis WHERE: HOW: https://www.eventbrite.com/e/rakastella-2018-by-innervisions-life-and-death-tickets-46128112426 Nikki Beach, 1 Ocean Drive WHEN: Saturday, December 8, 8pmWHAT: Airthereum party WHERE: HOW: https://www.eventbrite.com/o/fly-by-airthereum-18269671711 Soho Studios, 2136 NW 1st Avenue, Miami, FL, 33127 WHEN: Saturday, December 8, 10pm-3amWHAT: KaskadeWHERE: HOW: https://wl.seetickets.us/event/2018-BLNK-CNVS-Basel-Pass/373660 Racket, 150 NW 24th Street, Miami Beach, 33127 WHEN: Saturday, December 8, 9pm-3amWHAT: DJ Jazzy Jeff WHERE: HOW: https://www.eventbrite.com/e/jazzy-jeff-at-racket-art-basel-2018-tickets-52616606687 Basement at Miami Beach EDITION Hotel, 2901 Collins Avenue In List App WHEN: Saturday, December 8, 10pm–5amWHAT: Bedouin + Guy Laliberte WHERE: HOW: LIV Nightclub at Fontainebleau, 4441 Collins Avenue WHEN: Saturday, December 8, 11pm-5am WHAT: Calvin Harris Basel Edition at LIV WHERE: HOW: https://www.tixr.com/groups/liv/events/calvin-harris-basel-edition-11066

Art Basel Miami on the Blockchain

How to Build an e-Commerce App : Entrepreneur’s Guide

Authors: (1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz; (2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Table of Links Abstract & Introduction Threat Model Background and Related Work Methodology Experiments Setup Results Discussion Conclusion, Acknowledgments, and References Appendix 8 Conclusions By employing model-based reinforcement learning, MEME generates adversarial malware samples that successfully evade antivirus systems and train a surrogate model mimicking the target classifier accurately. Our experiments show that MEME surpasses existing methods in evasion rate, suggesting its potential for various applications, such as testing model robustness and enhancing cyber security against advanced persistent threats. Future work may involve exploring ensemble surrogates and other optimizations to enhance MEME’s performance further. Acknowledgments The authors acknowledge support from the Strategic Support for the Development of Security Research in the Czech Republic 2019–2025 (IMPAKT 1) program, by the Ministry of the Interior of the Czech Republic under No. VJ02010020 – AI-Dojo: Multi-agent testbed for the research and testing of AI-driven cyber security technologies. The authors acknowledge the support of NVIDIA Corporation with the donation of a Titan V GPU used for this research. References 1. Akiba, T., Sano, S., Yanase, T., Ohta, T., Koyama, M.: Optuna: A Next-generation Hyperparameter Optimization Framework. In: Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. pp. 2623–2631. KDD ’19, Association for Computing Machinery, New York, NY, USA (Jul 2019). https://doi.org/10.1145/3292500.3330701 2. Anderson, H.S., Kharkar, A., Filar, B., Evans, D., Roth, P.: Learning to Evade Static PE Machine Learning Malware Models via Reinforcement Learning (Jan 2018). https://doi.org/10.48550/arXiv.1801.08917, arXiv:1801.08917 [cs] 3. Anderson, H.S., Roth, P.: EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models (Apr 2018). https://doi.org/10.48550/arXiv.1804.04637, arXiv:1804.04637 [cs] 4. Bergstra, J., Bardenet, R., Bengio, Y., K´egl, B.: Algorithms for Hyper-Parameter Optimization. In: Advances in Neural Information Processing Systems. vol. 24. Curran Associates, Inc. (2011) 5. Brockman, G., Cheung, V., Pettersson, L., Schneider, J., Schulman, J., Tang, J., Zaremba, W.: OpenAI Gym (Jun 2016). https://doi.org/10.48550/arXiv.1606.01540, arXiv:1606.01540 [cs] 6. Ceschin, F., Botacin, M., Gomes, H.M., Oliveira, L.S., Gr´egio, A.: Shallow Security: on the Creation of Adversarial Variants to Evade Machine Learning-Based Malware Detectors. In: Proceedings of the 3rd Reversing and Offensive-oriented Trends Symposium. pp. 1–9. ROOTS’19, Association for Computing Machinery, New York, NY, USA (Feb 2020). https://doi.org/10.1145/3375894.3375898 7. Chandrasekaran, V., Chaudhuri, K., Giacomelli, I., Jha, S., Yan, S.: Exploring connections between active learning and model extraction. In: Proceedings of the 29th USENIX Conference on Security Symposium. pp. 1309–1326. SEC’20, USENIX Association, USA (Aug 2020) 8. Correia-Silva, J.R., Berriel, R.F., Badue, C., de Souza, A.F., Oliveira-Santos, T.: Copycat CNN: Stealing Knowledge by Persuading Confession with Random Non-Labeled Data. In: 2018 International Joint Conference on Neural Networks (IJCNN). pp. 1–8 (Jul 2018). https://doi.org/10.1109/IJCNN.2018.8489592, iSSN: 2161-4407 9. Demetrio, L., Biggio, B., Lagorio, G., Roli, F., Armando, A.: FunctionalityPreserving Black-Box Optimization of Adversarial Windows Malware. IEEE Transactions on Information Forensics and Security 16, 3469–3478 (2021). https://doi.org/10.1109/TIFS.2021.3082330, conference Name: IEEE Transactions on Information Forensics and Security 10. Demetrio, L., Coull, S.E., Biggio, B., Lagorio, G., Armando, A., Roli, F.: Adversarial exemples: A survey and experimental evaluation of practical attacks on machine learning for windows malware detection. ACM Transactions on Privacy and Security (TOPS) 24(4), 1–31 (2021), publisher: ACM New York, NY, USA 11. Dowling, S., Schukat, M., Barrett, E.: Using Reinforcement Learning to Conceal Honeypot Functionality. In: Brefeld, U., Curry, E., Daly, E., MacNamee, B., Marascu, A., Pinelli, F., Berlingerio, M., Hurley, N. (eds.) Machine Learning and Knowledge Discovery in Databases. pp. 341–355. Lecture Notes in Computer Science, Springer International Publishing, Cham (2019). https://doi.org/10.1007/978-3-030-10997-4 21 12. Fang, Y., Zeng, Y., Li, B., Liu, L., Zhang, L.: DeepDetectNet vs RLAttackNet: An adversarial method to improve deep learning-based static malware detection model. PLOS ONE 15(4), e0231626 (Apr 2020). https://doi.org/10.1371/journal.pone.0231626, publisher: Public Library of Science 13. Fang, Z., Wang, J., Geng, J., Kan, X.: Feature Selection for Malware Detection Based on Reinforcement Learning. IEEE Access 7, 176177–176187 (2019). https://doi.org/10.1109/ACCESS.2019.2957429, conference Name: IEEE Access 14. Fang, Z., Wang, J., Li, B., Wu, S., Zhou, Y., Huang, H.: Evading Anti-Malware Engines With Deep Reinforcement Learning. IEEE Access 7, 48867–48879 (2019). https://doi.org/10.1109/ACCESS.2019.2908033, conference Name: IEEE Access 15. Harang, R., Rudd, E.M.: SOREL-20M: A Large Scale Benchmark Dataset for Malicious PE Detection. arXiv:2012.07634 [cs] (Dec 2020), arXiv: 2012.07634 16. Hu, W., Tan, Y.: Generating Adversarial Malware Examples for Black-Box Attacks Based on GAN. In: Tan, Y., Shi, Y. (eds.) Data Mining and Big Data. pp. 409–423. Communications in Computer and Information Science, Springer Nature, Singapore (2022). https://doi.org/10.1007/978-981-19-8991-9 29 17. Huang, L., Zhu, Q.: Adaptive Honeypot Engagement Through Reinforcement Learning of Semi Markov Decision Processes. In: Alpcan, T., Vorobeychik, Y., Baras, J.S., D´an, G. (eds.) Decision and Game Theory for Security. pp. 196– 216. Lecture Notes in Computer Science, Springer International Publishing, Cham (2019). https://doi.org/10.1007/978-3-030-32430-8 13 18. Institute, A.T.: AV-ATLAS - Malware & PUA (2023), https://portal.av-atlas.org/malware 19. Jagielski, M., Carlini, N., Berthelot, D., Kurakin, A., Papernot, N.: High Accuracy and High Fidelity Extraction of Neural Networks. pp. 1345–1362 (2020) 20. Ke, G., Meng, Q., Finley, T., Wang, T., Chen, W., Ma, W., Ye, Q., Liu, T.Y.: LightGBM: A Highly Efficient Gradient Boosting Decision Tree. In: Advances in Neural Information Processing Systems. vol. 30. Curran Associates, Inc. (2017) 21. Kurutach, T., Clavera, I., Duan, Y., Tamar, A., Abbeel, P.: Model-Ensemble TrustRegion Policy Optimization. In: International Conference on Learning Representations (2018) 22. Labaca-Castro, R., Franz, S., Rodosek, G.D.: AIMED-RL: Exploring Adversarial Malware Examples with Reinforcement Learning. In: Dong, Y., Kourtellis, N., Hammer, B., Lozano, J.A. (eds.) Machine Learning and Knowledge Discovery in Databases. Applied Data Science Track. pp. 37–52. Lecture Notes in Computer Science, Springer International Publishing, Cham (2021). https://doi.org/10.1007/978-3-030-86514-6 3 23. Li, X., Li, Q.: An IRL-based malware adversarial generation method to evade anti-malware engines. Computers & Security 104, 102118 (May 2021). https://doi.org/10.1016/j.cose.2020.102118 24. Ling, X., Wu, L., Zhang, J., Qu, Z., Deng, W., Chen, X., Qian, Y., Wu, C., Ji, S., Luo, T., Wu, J., Wu, Y.: Adversarial attacks against Windows PE malware detection: A survey of the state-of-the-art. Computers & Security 128, 103134 (May 2023). https://doi.org/10.1016/j.cose.2023.103134 25. Lundberg, S.M., Lee, S.I.: A Unified Approach to Interpreting Model Predictions. In: Advances in Neural Information Processing Systems. vol. 30. Curran Associates, Inc. (2017) 26. Nguyen, T.T., Reddi, V.J.: Deep Reinforcement Learning for Cyber Security. IEEE Transactions on Neural Networks and Learning Systems pp. 1–17 (2021). https://doi.org/10.1109/TNNLS.2021.3121870, conference Name: IEEE Transactions on Neural Networks and Learning Systems 27. Orekondy, T., Schiele, B., Fritz, M.: Knockoff Nets: Stealing Functionality of BlackBox Models. pp. 4954–4963 (2019) 28. Pal, S., Gupta, Y., Shukla, A., Kanade, A., Shevade, S., Ganapathy, V.: ActiveThief: Model Extraction Using Active Learning and Unannotated Public Data. Proceedings of the AAAI Conference on Artificial Intelligence 34(01), 865–872 (Apr 2020). https://doi.org/10.1609/aaai.v34i01.5432, number: 01 29. Phan, T.D., Duc Luong, T., Hoang Quoc An, N., Nguyen Huu, Q., Nghi, H.K., Pham, V.H.: Leveraging Reinforcement Learning and Generative Adversarial Networks to Craft Mutants of Windows Malware against Black-box Malware Detectors. In: Proceedings of the 11th International Symposium on Information and Communication Technology. pp. 31–38. SoICT ’22, Association for Computing Machinery, New York, NY, USA (Dec 2022) 30. Quertier, T., Marais, B., Morucci, S., Fournel, B.: MERLIN – Malware Evasion with Reinforcement LearnINg (Mar 2022), arXiv:2203.12980 [cs] 31. Raffin, A., Hill, A., Gleave, A., Kanervisto, A., Ernestus, M., Dormann, N.: StableBaselines3: Reliable Reinforcement Learning Implementations. Journal of Machine Learning Research 22(268), 1–8 (2021) 32. Rigaki, M., Garcia, S.: Stealing and evading malware classifiers and antivirus at low false positive conditions. Computers & Security 129, 103192 (Jun 2023). https://doi.org/10.1016/j.cose.2023.103192 33. Rosenberg, I., Meir, S., Berrebi, J., Gordon, I., Sicard, G., Omid David, E.: Generating End-to-End Adversarial Examples for Malware Classifiers Using Explainability. In: 2020 International Joint Conference on Neural Networks (IJCNN). pp. 1–10 (Jul 2020). https://doi.org/10.1109/IJCNN48605.2020.9207168, iSSN: 2161-4407 34. Sanyal, S., Addepalli, S., Babu, R.V.: Towards Data-Free Model Stealing in a Hard Label Setting. pp. 15284–15293 (2022) 35. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., Klimov, O.: Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347 (2017) 36. Security.org, T.: 2023 Antivirus Market Annual Report (Feb 2023), https://www.security.org/antivirus/antivirus-consumer-report-annual/ 37. Severi, G., Meyer, J., Coull, S., Oprea, A.: Explanation-Guided Backdoor Poisoning Attacks Against Malware Classifiers. In: 30th USENIX Security Symposium (USENIX Security 21). pp. 1487–1504. USENIX Association (2021) 38. Song, W., Li, X., Afroz, S., Garg, D., Kuznetsov, D., Yin, H.: MAB-Malware: A Reinforcement Learning Framework for Blackbox Generation of Adversarial Malware. In: Proceedings of the 2022 ACM on Asia Conference on Computer and Communications Security. pp. 990–1003. ASIA CCS ’22, Association for Computing Machinery, New York, NY, USA (May 2022). https://doi.org/10.1145/3488932.3497768 39. Sussman, B.: New Malware Is Born Every Minute (May 2023), https://blogs.blackberry.com/en/2023/05/new-malware-born-every-minute 40. Sutton, R.S., Barto, A.G.: Reinforcement Learning, second edition: An Introduction. MIT Press (Nov 2018) 41. Total, V.: VirusTotal - Stats, https://www.virustotal.com/gui/stats 42. Uprety, A., Rawat, D.B.: Reinforcement Learning for IoT Security: A Comprehensive Survey. IEEE Internet of Things Journal 8(11), 8693–8706 (Jun 2021). https://doi.org/10.1109/JIOT.2020.3040957, conference Name: IEEE Internet of Things Journal 43. Wu, C., Shi, J., Yang, Y., Li, W.: Enhancing Machine Learning Based Malware Detection Model by Reinforcement Learning. In: Proceedings of the 8th International Conference on Communication and Network Security. pp. 74–78. ICCNS 2018, Association for Computing Machinery, New York, NY, USA (Nov 2018). https://doi.org/10.1145/3290480.3290494 44. Zolotukhin, M., Kumar, S., H¨am¨al¨ainen, T.: Reinforcement Learning for Attack Mitigation in SDN-enabled Networks. In: 2020 6th IEEE Conference on Network Softwarization (NetSoft). pp. 282–286 (Jun 2020). https://doi.org/10.1109/NetSoft48620.2020.9165383 45. Sembera, V., Paquet-Clouston, M., Garcia, S., Erquiaga, M.J.: Cybercrime Spe- ˇ cialization: An Expos´e of a Malicious Android Obfuscation-as-a-Service. In: 2021 IEEE European Symposium on Security and Privacy Workshops (EuroS&PW. pp. 213–236 (2021). https://doi.org/10.1109/EuroSPW54576.2021.00029 This paper is under CC BY-NC-SA 4.0 DEED license. available on arxiv

Enhancing Cybersecurity with MEME: Reinforcement Learning for Adversarial Malware Evasion

Authors: (1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz; (2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Table of Links Abstract & Introduction Threat Model Background and Related Work Methodology Experiments Setup Results Discussion Conclusion, Acknowledgments, and References Appendix 6 Results 6.1 Malware Evasion To evaluate MEME, we tested its evasion capabilities compared to four other algorithms. Figure 3 shows the evasion rates of all algorithms against four different targets. Generally, we can see that some targets are more challenging than others. For example, the Sorel-FFNN target seems the hardest to evade, while Ember seems the easiest. MEME outperforms the PPO algorithm in all four targets, with a difference in mean evasion rate between 5-10% depending on the target. This result indicates that creating a surrogate model and running additional training steps is beneficial and produces a better policy. MEME also outperforms MAB in three out of four targets and GAMMA in all four, showing stable overall performance. GAMMA is the only method affected by the time constraint and, in most experiments, manages to process less than 100 binaries. However, it performs almost as well as MEME on the Sorel-FFNN. This shows that the RL methods, including MAB, did not learn the simple strategy of section injection that GAMMA uses, which is part of their action set. Average number of binary modifications to evade the target. The numbers for MAB correspond to the minimal samples created. Random, PPO, and MEME numbers correspond to the mean episode length of the final evaluation on the test set. Table 2. The AV evasion rate was over 50% for both PPO and MEME, with MEME achieving an average evasion rate of 59%. This demonstrates that even though AV is more complex than a single classifier, it can still be bypassed. In terms of required modifications for a malicious binary to appear benign (Table 2), MEME has the lowest average changes against Sorel-FFNN and Microsoft Defender. MAB performs better with lower average changes against Ember and Sorel-LGB, as it aims to minimize the required actions. However, if MAB struggles with evasion, the average modifications increase. Unfortunately, it was not possible to get the number of modifications for each binary from the GAMMA attack since the framework that implements the attack does not provide this metric. Surrogate agreement metrics with the test set for each target model. Table 3. 6.2 Surrogate Evaluation Table 3 shows the agreement scores of the surrogate models with their respective targets. The label agreement scores were higher than 97% for all targets. In the feature agreement metrics, 9 out of 10 top features, according to SHAP feature importances were the same for the Ember target and the respective surrogates. The percentage is slightly lower for Sorel-LGB, with 7.2 out of the top 10 feature agreement and 16.2 out of the top 20. However, the feature agreement metrics get significantly lower regarding the Sorel-FFNN target, even though the label agreement is higher than 98%. This target is also the harder one to evade for the RL-based methods. This high level of label agreement was reached with only 2,048 queries, significantly lower than reported in prior work (25k) [32]. This paper is under CC BY-NC-SA 4.0 DEED license. available on arxiv

MEME vs. PPO: Analyzing Evasion Rates and Binary Modifications in Malware Detection

Authors: (1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz; (2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Table of Links Abstract & Introduction Threat Model Background and Related Work Methodology Experiments Setup Results Discussion Conclusion, Acknowledgments, and References Appendix 5 Experiments Setup To evaluate MEME, several experiments were conducted in different configurations. First, there was a selection of four different malware detection solutions as targets to evade. Second, there was a comparison of MEME and four other evasion techniques on these four targets. 5.1 Targets The selection of targets was made to include three highly cited malware detection models together with a real implementation of a popular free Antivirus solution. 1. Ember. A LightGBM [20] model that was released as part of the Ember dataset [3] which was used for training that same model. The decision threshold was set to 0.8336, which corresponds to a 1% false positive rate (FPR) on the Ember 2018 test set. 2. Sorel-LGB. A LightGBM model that was distributed as part of the Sorel20M [15] dataset, which was used for training that same model. The decision threshold was set to 0.5, which corresponds to a 0.2% false positive rate (FPR) on the Sorel-20M test set. 3. Sorel-FFNN. A feed-forward neural network (FFNN) that was also released as part of the Sorel 20M dataset and was trained using the same data. The decision threshold was set to 0.5, which corresponds to 0.6% false positive rate (FPR) on the Sorel-20M test set. 4. Microsoft Defender. An antivirus product that comes pre-installed with the Windows operating system. According to [36], it is the most used free antivirus product for personal computers. All tests were performed using a virtual machine (VM) running an updated version of the product. The VM had no internet connectivity during the binary file scanning. 5.2 Datasets Our experiments required the use of the following datasets: 1. Ember 2018. A dataset that consists of features extracted from one million Windows Portable Executable (PE) files [3]. The dataset is split into training, testing, and ”unlabeled sets”. The training set consists of 300,000 clean samples, 300,000 malicious samples, and 200,000 “unlabeled” samples. The so-called unlabeled part of the dataset was truly unlabeled in the first version of the dataset, however, in the 2018 release, the authors provided an avclass label for all malicious samples, including those in the unlabeled set. Each sample has 2,381 static features related to byte and entropy histograms, PE header information, strings, imports, data directories, etc. 2. Sorel-20M. The Sorel dataset [15] was released in 2020 and contains the extracted features of 20 million binary files (malicious and benign). The feature set used was the same as the one from the Ember dataset. 3. Malware Binary Files. In addition to the Ember features used for training the surrogate, we also obtained 1,000 malicious binary files whose hashes were part of Ember 2018 and we use them for generating the evasive malware with all the methods. 4. Benign Binary Files. All methods require a benign set of data from where they extract benign strings, sections, and other elements that are used for the binary modifications. The same set of 100 benign binaries were used in all experiments. The files were obtained from a Windows 10 virtual machine after installing known benign software. MEME created two versions of the Daux dataset to train the surrogate models. For the Ember and AV surrogates, Daux contains the unlabeled part of the Ember dataset. For the Sorel surrogates, Daux contains 200,000 samples from the Sorel-20M validation set. These datasets were chosen to create the surrogate because they were not used to train the corresponding targets. During the evaluation, a subset of the Sorel-20M test set was used to evaluate the performance of the Sorel surrogate models and the Ember test set was used to evaluate the Ember and AV models. The 1,000 malware binaries were split into training and test sets with a 70-30% ratio using five different seeds. The test sets were used to test all the methods, while the 700 binaries in the training set were used to train each of the RL policies for PPO and MEME (these were the binaries to which modifier actions were applied). 5.3 Adversarial Malware Generation Comparison With regard to the generation of adversarial malware, MEME is compared with four algorithms in total. Two baseline reinforcement learning algorithms that use the Malware-Gym environment: a random agent and an agent that learns a policy using the vanilla Proximal Policy Optimization (PPO) algorithm [35], and two state-of-the-art (SOTA) algorithms: MAB [38] and GAMMA [9]. The two SOTA algorithms were selected based on the fact that they are relatively recently released and the fact that they seem to perform well in the malware evasion task. In addition, their source code is available. The detailed setup used for each of the algorithms, as well as any modifications, are presented below: 1. Random Agent The random agent is the simplest baseline used in our experiments. It uses the Malware-Gym environment and randomly samples the next modification action from the available action space. The agent is evaluated in the test environments using the 300 test malware samples. 2. PPO This is an agent that uses the PPO [35] algorithm as implemented in the Stable-Baselines3 software package. The agent was trained for 2,048 steps on the malware training set and evaluated on the malware test set. To select the hyper-parameters related to PPO training, we used the Tree-structured Parzen Estimator (TPE) method [4] as implemented in the software package Optuna [1]. The TPE algorithm was executed with the Ember dataset, but the settings performed well in the other targets. The tuned hyper-parameters were γ, the learning rate, the maximum gradient norm, the activation function, and the neural network size for the actor and critic models. The search space of each parameter and the final values are presented in the Appendix. 3. MAB RL algorithm that treats the evasive malware generation as a multiarmed bandit problem2. It operates in two stages: evasion and minimization. It samples the action space, which includes generic actions (similar to Malware-Gym) and any successful evasive actions along with the specific modifiers, e.g., appending a specific benign section. MAB directly manipulates each binary without generating a learned policy. Therefore, all experiments were conducted directly on the malicious binary test set. 4. GAMMA An algorithm that injects benign binary sections into malicious PE files while preserving their functionality. It modifies features like section count, byte histograms, and strings, leaving features related to, e.g., certificates and debugging data unaffected. By employing genetic algorithms, GAMMA searches for optimal benign sections to reduce the target model’s confidence by minimizing the content and location of injected sections. The attack is implemented in the SecML library3. Though effective, it has a significantly longer runtime than other tested methods. The attack uses a restricted set of 30 available benign sections and a population size of 20. The λ parameter, impacting the injected data size, was set to 10−6. GAMMA directly operates on each binary and does not generate a learned policy. Hence, all experiments were conducted on the malicious binary test set. 5.4 MEME Experimental Setup The initial training steps n in Algorithm 1 were set to 1,024, and the total number of loops k was two. For evaluation, the test set of 300 malware binaries was used. The surrogate training steps m were set to 2,048 (step 6 of Algorithm 1). MEME utilizes PPO for training and updating the policy (πθ). The PPO settings remained the same as in the baseline experiments, enabling a comparison of the impact of using a surrogate model for additional PPO training. In total, there were a total of 2,048 queries to the target and 4,096 training steps using the surrogate environment. The surrogate was always a LightGBM model. Surrogate training involved two datasets: Daux from an external dataset (e.g., Ember 2018 or Sorel-20M) and Dsur generated during lines 3 and 7 of Algorithm 1. These datasets were mixed with a ratio α, a hyperparameter for LGB surrogate tuning. Other hyperparameters, such as the number of boosting trees, learning rate, tree depth, minimum child samples, and feature fraction, were also tuned separately for each target using TPE and Optuna. Appendix A provides the detailed search space and selected values. Surrogate models were evaluated using the respective target test sets, and a decision threshold matching target FPR levels was calculated. For the AV target without a representative dataset, the surrogate’s decision threshold was set to 0.5. 5.5 General Experiment Settings All the algorithms were tested under a common set of constraints. The maximum allowed modifications to a binary file were set to 15 for the RL-based algorithms. Similarly, for GAMMA, the number of iterations was set to 15; for MAB, the number of ”pulls” was also 15. The second constraint was to set the maximum running time for all experiments to 4 hours. For MAB and GAMMA, this setting means that the algorithms must manage to handle as many malicious binaries as possible in that time. At the same time, for PPO and MEME, this time included both the policy training time and the evaluation time. For PPO and MEME, we set the query budget to 2,048. This budget does not include the final evaluation queries on the test set. MAB and GAMMA were not constrained in the total number of queries because it is not supported by the respective frameworks. Finally, all experiments were run with five different seeds. The random seeds controlled the split of the 1,000 malicious binaries into train and test, and therefore, all methods were tested in the same files. This paper is under CC BY-NC-SA 4.0 DEED license. available on arxiv

MEME Algorithm's Impact on Adversarial Malware Generation and Model Evasion

Authors:
(1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz;
(2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Table of Links Abstract & Introduction Threat Model Background and Related Work Methodology Experiments Setup Results Discussion Conclusion, Acknowledgments, and References Appendix 4 Methodology The MEME algorithm combines model extraction and reinforcement learning (RL) techniques to improve the generation of evasive malware binaries. The algorithm takes advantage of the fact that the attacker fully controls the binary modifier part of the environment but does not control the target model, which is a black box. However, an attacker can use data collected during the training of the RL agent to create and train a surrogate model of the target. The algorithm is implemented as several training/testing rounds until a final reinforcement learning policy is learned that can produce adversarial binaries for a given target. Figure 2 presents a high-level description of the algorithm, and the detailed listing is presented in Algorithm 1. Following Algorithm 1, MEME initializes a Proximal Policy Optimization (PPO) RL algorithm [35 (lines 1 and 2) to perform a first train of the PPO policy using the target model and a limited amount of steps (using MalwareGym). The goal of this step is to store a small number of observations and labels in Dsur (line 3). Then, Dsur is combined with an auxiliary set of labeled data (Daux) that the attacker should possess, and this combined dataset is used to train a surrogate model for the model extraction attack (line 5). The improved surrogate replaces the target model in a new Malware-Gym environment that trains a better policy (agent) for evasion (line 6). Last, the improved policy is evaluated against the original target model (line 7) to obtain the final evasion metrics. In this last step, we take advantage of the queries done to the target to append their output to the Dsur dataset. This loop is repeated for k rounds. During the last round, the evaluation is performed using the malware binary test set to produce the final evasion metrics (instead of the malware binary evaluation set used in the inner loop). The total number of queries to the target during training is k ∗ n, where k is the total number of rounds. For learning the policy, we use the PPO algorithm, which is a model-free onpolicy gradient method that clips the objective function, limiting the updates done to the policy to avoid too large positive changes or a minimum of negative changes in order to stabilize it. We used the Stable Baselines3 [31] implementation of PPO that uses an Actor-Critic (A2C) architecture. To train the surrogate model, it is not enough to use the data collected during the learning or evaluation of the agent in Dsur. The number of samples is not enough since we aim to minimize the queries to the target. In addition, all observations come from the extracted features of the malicious binary dataset or their adversarial modifications. Therefore using an auxiliary dataset is necessary to learn a good surrogate. This dataset is assumed to be from a similar distribution as the training data distribution of the target, however, this is not easy to achieve when the target is an AV or an unknown system. Adaptations to the Gym Environment MEME was implemented around the Malware-Gym environment (Section 3.1) in its latest version1. Several modifications were applied to the environment to fit the assumptions and constraints for this work: – The ”modify machine type” action was removed because our tests showed that it produces invalid binaries for Windows 10 systems. – All targets were set to return hard labels (0 or 1), not scores. – Regarding the benign sections, the Malware-Gym implementation used only data from ”.text” sections. In our implementation, we use data from other sections if the ”.text” section is unavailable. – The latest environment supports the Ember and Sorel-LGB classifiers as targets. We added new environments to support the Sorel-FFNN, surrogate, and AV targets. The AV requires a web service in a virtual machine that invokes the AV static scanning capabilities. – For all target environments, we added support for saving the observations (features) and scores during training and evaluation runs so that they can be used for the training of the surrogate. Our version of the environment and the experiments performed as part of this work can be found in (https://github.com/stratosphereips/meme malware rl/releases/tag/v1.0). Please note that we are releasing the source code of our implementation for reproducibility and improvement; however, we do not release the trained models or agents to avoid potential misuse. 4.1 Evasion Evaluation To evaluate the performance of the evasion models reasonably and realistically, we limited how many queries they do to the target model and how long they run. The idea behind liming running time is that the ratio at which malware authors create new malware is high, and a method that takes too long to create evasive malware is impractical. Industry measurements such as the ones provided by AV-ATLAS [18] report that 180 new malware are generated per minute. Virus Total [41] provides an even higher measurement of 560 distinct new files uploaded per minute as of the 21st of May, 2023. These global measurements vary but show how quickly new malware variants appear, possibly due to the proliferation of Malware-as-a-Service frameworks. A recent and more conservative measurement from Blackberry mentions that their customers get attacked by 1.5 new malware per minute [39]. Given the above measurements, we decided to constrain the running time of each experiment to four hours in total. Given that the test set consists of 300 malware binaries, this corresponds to 1.25 processed binaries per minute which is lower than the most conservative reported metric we could find. The primary metric used to evaluate the malware evasion task was the evasion rate E, which is the fraction of malware that becomes evasive within the time window of four hours over the total number of malware that were initially detected by each target: E = nev/ndet . We also report the average number of binary modifications required for a malware binary to evade the target. For the Random, PPO, and MEME methods, this is equivalent to the mean episode length over all the detected malware binaries in the test set. The episode length for a non-evasive binary is equal to the maximum number of attempts, and for an evasive one is the number of changes required to become evasive. For the MAB framework, for the evasive binaries, we considered only the minimal binaries with the least amount of actions. The average number of binary modifications was impossible to measure for the GAMMA attack since the SecML framework (through which GAMMA was implemented) does not provide a straightforward way to measure this metric. 4.2 Surrogate Evaluation The surrogate models trained in MEME were evaluated using two different metrics: label agreement and explainability-based feature agreement [37]. The label agreement of two models f and ˆf, respectively, is defined as the average number of similar predictions over a test set Xtest, and it is a standard metric for model extraction fidelity attacks [19]: The feature agreement metric computes the fraction of common features between the sets of top-k features of two explanations. Given two explanations Et (target) and Es (surrogate), the feature agreement metric can be formally defined as: where top features(E, k) returns the set of top-k features of the explanation E based on the magnitude of the feature importance values. The maximum value of the feature agreement is 1. For this work, we measured the feature agreement for k = 10 and k = 20, and the explainability method used was SHAP (SHapley Additive exPlanations) [25]. SHAP employs game theory principles to explain machine learning model outputs by linking effective credit allocation with localized explanations via Shapley values that originated from game theory. SHAP is model-agnostic and has been used effectively in the past for adversarial malware creation [33]. For the LightGBM targets we used TreeSHAP which is designed specifically for tree models, while for Sorel FFNN we used the KernelSHAP variant. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz; (2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Authors: Authors: (1) Maria Rigaki, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and maria.rigaki@fel.cvut.cz; (2) Sebastian Garcia, Faculty of Electrical Engineering, Czech Technical University in Prague, Czech Republic and sebastian.garcia@agents.fel.cvut.cz. Table of Links Abstract & Introduction Abstract & Introduction Threat Model Threat Model Background and Related Work Background and Related Work Methodology Methodology Experiments Setup Experiments Setup Results Results Discussion Discussion Conclusion, Acknowledgments, and References Conclusion, Acknowledgments, and References Appendix Appendix 4 Methodology The MEME algorithm combines model extraction and reinforcement learning (RL) techniques to improve the generation of evasive malware binaries. The algorithm takes advantage of the fact that the attacker fully controls the binary modifier part of the environment but does not control the target model, which is a black box. However, an attacker can use data collected during the training of the RL agent to create and train a surrogate model of the target. The algorithm is implemented as several training/testing rounds until a final reinforcement learning policy is learned that can produce adversarial binaries for a given target. Figure 2 presents a high-level description of the algorithm, and the detailed listing is presented in Algorithm 1. Following Algorithm 1, MEME initializes a Proximal Policy Optimization (PPO) RL algorithm [35 (lines 1 and 2) to perform a first train of the PPO policy using the target model and a limited amount of steps (using MalwareGym). The goal of this step is to store a small number of observations and labels in Dsur (line 3). Then, Dsur is combined with an auxiliary set of labeled data (Daux) that the attacker should possess, and this combined dataset is used to train a surrogate model for the model extraction attack (line 5). The improved surrogate replaces the target model in a new Malware-Gym environment that trains a better policy (agent) for evasion (line 6). Last, the improved policy is evaluated against the original target model (line 7) to obtain the final evasion metrics. In this last step, we take advantage of the queries done to the target to append their output to the Dsur dataset. This loop is repeated for k rounds. During the last round, the evaluation is performed using the malware binary test set to produce the final evasion metrics (instead of the malware binary evaluation set used in the inner loop). The total number of queries to the target during training is k ∗ n, where k is the total number of rounds. For learning the policy, we use the PPO algorithm, which is a model-free onpolicy gradient method that clips the objective function, limiting the updates done to the policy to avoid too large positive changes or a minimum of negative changes in order to stabilize it. We used the Stable Baselines3 [31] implementation of PPO that uses an Actor-Critic (A2C) architecture. To train the surrogate model, it is not enough to use the data collected during the learning or evaluation of the agent in Dsur. The number of samples is not enough since we aim to minimize the queries to the target. In addition, all observations come from the extracted features of the malicious binary dataset or their adversarial modifications. Therefore using an auxiliary dataset is necessary to learn a good surrogate. This dataset is assumed to be from a similar distribution as the training data distribution of the target, however, this is not easy to achieve when the target is an AV or an unknown system. Adaptations to the Gym Environment MEME was implemented around the Malware-Gym environment (Section 3.1) in its latest version1. Several modifications were applied to the environment to fit the assumptions and constraints for this work: Adaptations to the Gym Environment – The ”modify machine type” action was removed because our tests showed that it produces invalid binaries for Windows 10 systems. – All targets were set to return hard labels (0 or 1), not scores. – Regarding the benign sections, the Malware-Gym implementation used only data from ”.text” sections. In our implementation, we use data from other sections if the ”.text” section is unavailable. – The latest environment supports the Ember and Sorel-LGB classifiers as targets. We added new environments to support the Sorel-FFNN, surrogate, and AV targets. The AV requires a web service in a virtual machine that invokes the AV static scanning capabilities. – For all target environments, we added support for saving the observations (features) and scores during training and evaluation runs so that they can be used for the training of the surrogate. Our version of the environment and the experiments performed as part of this work can be found in (https://github.com/stratosphereips/meme malware rl/releases/tag/v1.0). Please note that we are releasing the source code of our implementation for reproducibility and improvement; however, we do not release the trained models or agents to avoid potential misuse. 4.1 Evasion Evaluation To evaluate the performance of the evasion models reasonably and realistically, we limited how many queries they do to the target model and how long they run. The idea behind liming running time is that the ratio at which malware authors create new malware is high, and a method that takes too long to create evasive malware is impractical. Industry measurements such as the ones provided by AV-ATLAS [18] report that 180 new malware are generated per minute. Virus Total [41] provides an even higher measurement of 560 distinct new files uploaded per minute as of the 21st of May, 2023. These global measurements vary but show how quickly new malware variants appear, possibly due to the proliferation of Malware-as-a-Service frameworks. A recent and more conservative measurement from Blackberry mentions that their customers get attacked by 1.5 new malware per minute [39]. Given the above measurements, we decided to constrain the running time of each experiment to four hours in total. Given that the test set consists of 300 malware binaries, this corresponds to 1.25 processed binaries per minute which is lower than the most conservative reported metric we could find. The primary metric used to evaluate the malware evasion task was the evasion rate E, which is the fraction of malware that becomes evasive within the time window of four hours over the total number of malware that were initially detected by each target: E = nev/ndet . We also report the average number of binary modifications required for a malware binary to evade the target. For the Random, PPO, and MEME methods, this is equivalent to the mean episode length over all the detected malware binaries in the test set. The episode length for a non-evasive binary is equal to the maximum number of attempts, and for an evasive one is the number of changes required to become evasive. For the MAB framework, for the evasive binaries, we considered only the minimal binaries with the least amount of actions. The average number of binary modifications was impossible to measure for the GAMMA attack since the SecML framework (through which GAMMA was implemented) does not provide a straightforward way to measure this metric. 4.2 Surrogate Evaluation The surrogate models trained in MEME were evaluated using two different metrics: label agreement and explainability-based feature agreement [37]. The label agreement of two models f and ˆf, respectively, is defined as the average number of similar predictions over a test set Xtest, and it is a standard metric for model extraction fidelity attacks [19]: The feature agreement metric computes the fraction of common features between the sets of top-k features of two explanations. Given two explanations Et (target) and Es (surrogate), the feature agreement metric can be formally defined as: where top features(E, k) returns the set of top-k features of the explanation E based on the magnitude of the feature importance values. The maximum value of the feature agreement is 1. For this work, we measured the feature agreement for k = 10 and k = 20, and the explainability method used was SHAP (SHapley Additive exPlanations) [25]. SHAP employs game theory principles to explain machine learning model outputs by linking effective credit allocation with localized explanations via Shapley values that originated from game theory. SHAP is model-agnostic and has been used effectively in the past for adversarial malware creation [33]. For the LightGBM targets we used TreeSHAP which is designed specifically for tree models, while for Sorel FFNN we used the KernelSHAP variant. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. available on arxiv

MEME Algorithm: Optimizing Malware Evasion Through Model Extraction and Reinforcement Learning

**JERUSALEM, Israel, March 28th, 2024/Cyberwire/--**In 2023 alone, more than 10 customers and partners signed commercial agreements with C2A Security, including a global, long term enterprise agreement with an European Commercial Vehicle Manufacturer. C2A Security’s DevSecOps Platform, ‘EVSec’, has been gaining widespread traction as the automotive industry rushes to meet cybersecurity regulations and industry standards, such as UN Regulation No. 155, ISO/SAE 21434, Chinese GB Standards, and others. 2024 is a pivotal year for cybersecurity regulations in the automotive industry, as UN Regulation No. 155 goes into full effect. C2A Security’s EVSec risk-driven product security platform allows developers to focus on creative features and manage software and operations at scale, in an automated manner. EVSec automates archaic manual processes and enables cross-functional sharing and collaboration between teams, customers, and supply chains while offering full digital twin capabilities. EVSec applies continuous feedback from product operations and vulnerabilities to improve development and design, as part of agile software development. In 2023, C2A Security added multiple OEMs and Tier 1s to its portfolio of customers, successful evaluations, and partnerships such as Daimler Truck AG, BMW Group, Marelli, NTT Data, Siemens, and Valeo, among others. The collaboration with C2A Security supports the customers on the applicable standards and best practices for regulatory compliance. EVSec maps and automates the relevant standards and regulations, like ISO/SAE 21434 and UN Regulation No. 155, to simplify compliance efforts, which are essential to business success, as companies forge new grounds for their vehicles, develop innovative EV-powered vehicles, and plan for the EV infrastructure that supports them. “We’re thrilled that EVSec has proven so popular and effective, as companies like Daimler Truck AG choose it as its product security platform. Dealing with current and emerging regulatory demands, software development at scale and overall product security operations can be a limitation on business continuity of a company if not automated,” noted Roy Fridman, CEO, C2A Security. “At the end of 2023, we witnessed the first case of a premium car maker that stopped the sale of their most popular model in the European Union because it failed to comply with the regulation. To stay competitive companies must utilize advanced product security automation in their development and operations and we are excited to support them in achieving this goal.” Images available . here About C2A Security C2A Security is the only risk-driven DevSecOps Platform vendor that addresses the specific needs of car makers, Tier 1 suppliers, and mobility companies. Founded in 2016, C2A Security’s customers and technology partners include top-tier global players including Daimler Truck AG, BMW Group, Siemens, Valeo, ThunderSoft, Marelli, NTT Data, and Evvo Labs, among others. C2A Security transforms cybersecurity from being a company-wide limitation to a business value multiplier through advanced security automation and compliance to shorten software release times and decrease costs. Our vision is to turn product security into a seamless, automated, and transparent process, reducing time to deployment and costs of managing automotive software products and resources. C2A Security was founded by NDS/Cisco veteran Michael Dick, with its global headquarters in Jerusalem, Israel. . www.c2a-sec.com Contact Estee Yaari C2A Security estee.yaari@gmail.com This story was distributed as a release by Cyberwire under HackerNoon’s Business Blogging Program. Learn more about the program here.

EVSec Risk Management And Automation Platform Gains Traction In Automotive Industry 

Life happily carries on and we don’t even have to look at our own darkness. Perhaps the real problem with modern life is the benign micro-systems that foster the covert conspiracy- we agree to blame the world for things that are, in fact, within us all. Implicitly we agree to live in a superficial dystopia of masks and make-up, where the wounds of psyche and identity stay hidden below the surface. The very comforts that our system affords us, also engage us in a conspiracy of denial, where we avoid the discomfiting process of taking a deep look within, and consequently, we allow the demons free space in our psyche. That’s why the unacknowledged, negative parts of us don’t simply lay dormant; they affect our thinking and our behavior, both conscious and unconscious, in ways that can be insidious and even destructive. Recognizing our shadows is a positive expression of our autonomy, an alternative to the easy way of least resistance, it is a refusal to ignore parts of ourselves, and a positive act of contact with that essential but compromised figure we all carry around inside our heads in the form of ‘I’. Recognition, then, is neither masochism nor resigned submission to this feature of our psychology. It is a positive move towards genuine self-awareness, which – by integrating in this way the previously separate shadow, by bringing that shadow into the full light of consciousness – is then powerless to continue the task it set itself, i.e, to deceive us into projecting onto other people the pain or injustice it embodies. No longer can we be unsuspecting hosts for the behaviors that are put to use by the shadow with such vicious selectivity. It takes courage and defiance to engage in this process of recognition – both externally and inwardly – to challenge how confinement insulates us from the truth of our ambivalence, how confinement requires people to live in a suspended way, aware of only part of themselves. If we allow ourselves to acknowledge the full range of our humanity, we open ourselves to a greater capacity for change. There is power in the acknowledgment of our demons, which changes their ability to function in the dark; it will not make us immune to them, but it should let us manage them better. Knowing that we have a dark side expands our compassion towards ourselves and others. We all are fighting a battle within, and this makes us vulnerable to each other. But awareness can transform vulnerability into a source of solidarity. In fact, this recognition opens the door for a more equitable and empathetic society. In owning our inner conflict, we reduce the risk of projecting it onto others. This creates space for a culture of accountability and a compassionate conversation with our shadow as an integral part of the work of being in this world. It transforms the myth of ‘what was done’ to ‘what I’ve done’, and perhaps becomes a lifelong conversation with our courageous and compassionate inner voice: ‘This is what was done to me. Now, what can be done with it?’ To opt out of a system that not only permits but welcomes this denial of our demons is an act of profound individual and societal autonomy. It serves as an affirmation that we’re no longer willing to be accomplices to lying to ourselves and others; and, perhaps more vitally, that we decline to be complicit in the injustice of the status quo. Then, armed with this existential awareness of who we really are, we can begin to chart a course for a different kind of beings. We can let our actions become less reactive and more reflective, our behaviors less governed by dark assumptions, and conscious biases – and more the results of a holistic sense of self. In this emerging reality, autonomy and identity are no longer ideals we strive to achieve but realities we actively embody. They are a commitment to being human with grace, intentionality, and an intense dedication to becoming more fully human as individuals and a larger society. If we and create systems that nurture our deepest values, we unshackle ourselves from the painful inescapability of separate selves, and liberate ourselves to co-create a world in which human beings live their differences together in safety and dignity. pay attention to our demons,

Can Humanity's Systems Serve as Material Enablers for Evasion?

In this article, a Web application using the latest version of in a built image will be hosted on (Elastic Compute Cloud) and deployed by (Elastic Container Service) using an (Elastic Container Registry) containers repository. Angular Docker Amazon EC2 Amazon ECS Amazon ECR Prerequisites Before you start, you need to install and configure the tools below to create the Angular application and the Docker image and push the image to the repository on Amazon ECR. : Git is a distributed version control system and it will be used to sync the repository. git : Node.js is a JavaScript code runtime software based on Google's V8 engine. npm is a package manager for Node.js (Node.js Package Manager). They will be used to build and run the Angular application and install the libraries. Node.js and npm : Docker Engine is a command line utility tool for Docker and it will be used to create and run containers. Docker Engine IDE (e.g. or ): IDE (Integrated Development Environment) is a tool with a graphical interface to help in the development of applications and it will be used to develop the Angular application. Visual Studio Code WebStorm : AWS Command Line Interface is a command line utility tool for interacting with all Amazon Web Services services. AWS CLI Getting started Create the repository on Amazon ECR is a Docker containers registry service that enables you to store and manage container images. Amazon ECR Let's create and configure the account. Access the site and click on the button . 1. https://aws.amazon.com/ecr/ Get started with Amazon ECS Now we will click on the option , fill in the field and click on the button . 2. Root user Root user email address Next Note: If you don't have an Amazon account, do steps 1 to 9 of the post in the session . Authentication using the Amazon Cognito to an Angular application Create and configure the account on the Amazon Cognito Next, we will fill in the field and click on the button . 3. Password Sign in Then, we will type in the search field and click on the option . 4. ecr Elastic Container Registry After click on the option , we will click on the button . 5. Elastic Container Registry Get started Now we will click on the option , fill in the field and click on the button . 6. Public Repository name Create repository Next, we will click on the created repository and click on the button . 7. View push commands Then, we will copy the commands because they will be used to push the Docker image of the Angular application and click on the button . 8. Close Ready! The repository to store the Docker image of the Angular application was created. 9. Push the Docker image of the Angular application Let's use the Angular application created in the post . We will clone the repository . 1. Creating and running an Angular application in a Docker container https://github.com/rodrigokamada/angular-docker git clone https://github.com/rodrigokamada/angular-docker angular-docker-amazon-ecs Now we will change the file with the content below. 2. Dockerfile FROM node:alpine AS app

WORKDIR /usr/src/app

COPY . /usr/src/app

RUN npm install

RUN npm run build



FROM nginx:alpine

COPY --from=app /usr/src/app/dist/angular-docker/browser /usr/share/nginx/html

RUN ls /usr/share/nginx/html

COPY ./nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80 Notes: The setting defines the base Docker image of Node.js to build the Angular application. FROM node:alpine AS app The setting defines the default application directory. The defined directory is created if it does not exist. WORKDIR /usr/src/app The setting copies the local application files and directories to the defined directory. COPY . /usr/src/app The setting installs the Angular application dependencies. RUN npm install The setting compiles the Angular application. RUN npm run build The setting defines the base Docker image of NGINX to serve the Angular application files. FROM nginx:alpine The setting copies the compiled Angular application files to the NGINX directory. COPY --from=app /usr/src/app/dist/angular-docker/browser /usr/share/nginx/html The setting copies the NGINX configuration file to serve the Angular application. COPY ./nginx.conf /etc/nginx/conf.d/default.conf The setting defines the Docker port. NGINX uses the default port 80. EXPOSE 80 Next, we will create the file with the NGINX configuration in the root directory of the Angular application. 3. nginx.conf touch nginx.conf Then, we will configure the file with the content below. 4. nginx.conf server {
    listen 80;

    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
        try_files $uri $uri/ /index.html =404;
    }
} After configuring the file , we will authenticate the Docker client with the repository registry. 5. nginx.conf aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws/d3o6w2v8

Login Succeeded Now we will create the Docker image. 6. docker build -t angular-docker-amazon-ecs .
[+] Building 45.5s (10/10) FINISHED                                                                                                         docker:default
 => [internal] load build definition from Dockerfile                                                                                                  0.1s
 => => transferring dockerfile: 191B                                                                                                                  0.0s
 => [internal] load metadata for docker.io/library/node:alpine                                                                                        2.4s
 => [internal] load .dockerignore                                                                                                                     0.1s
 => => transferring context: 2B                                                                                                                       0.0s
 => [1/5] FROM docker.io/library/node:alpine@sha256:d3271e4bd89eec4d97087060fd4db0c238d9d22fcfad090a73fa9b5128699888                                  4.5s
 => => resolve docker.io/library/node:alpine@sha256:d3271e4bd89eec4d97087060fd4db0c238d9d22fcfad090a73fa9b5128699888                                  0.0s
 => => sha256:6af33fd59f0638fb0acc2992b2b54c7baf68fe593083f0f52815cf29d1288803 7.13kB / 7.13kB                                                        0.0s
 => => sha256:4abcf20661432fb2d719aaf90656f55c287f8ca915dc1c92ec14ff61e67fbaf8 3.41MB / 3.41MB                                                        1.0s
 => => sha256:2997c41553473c7c926a796f330b4a7b03e9d2a7a9ee059a66bf68e02040bf40 43.53MB / 43.53MB                                                      2.0s
 => => sha256:803074618b54a85228c5e10d79b5320e5eba82a2f89abddf233e852420430ba2 2.37MB / 2.37MB                                                        1.0s
 => => sha256:d3271e4bd89eec4d97087060fd4db0c238d9d22fcfad090a73fa9b5128699888 1.43kB / 1.43kB                                                        0.0s
 => => sha256:f5d3a6aea1b1d35066e6c034f5c264cd5b051fc7c7cb0160bb88899e7b1f0c83 1.16kB / 1.16kB                                                        0.0s
 => => extracting sha256:4abcf20661432fb2d719aaf90656f55c287f8ca915dc1c92ec14ff61e67fbaf8                                                             0.1s
 => => sha256:249f9271d1d17cdc2d12d106e2dcfafdc306da21f65123a06aa2290baa5c4fac 451B / 451B                                                            1.4s
 => => extracting sha256:2997c41553473c7c926a796f330b4a7b03e9d2a7a9ee059a66bf68e02040bf40                                                             1.7s
 => => extracting sha256:803074618b54a85228c5e10d79b5320e5eba82a2f89abddf233e852420430ba2                                                             0.3s
 => => extracting sha256:249f9271d1d17cdc2d12d106e2dcfafdc306da21f65123a06aa2290baa5c4fac                                                             0.0s
 => [internal] load build context                                                                                                                     0.1s
 => => transferring context: 683.88kB                                                                                                                 0.0s
 => [2/5] WORKDIR /usr/src/app                                                                                                                        0.3s
 => [3/5] COPY . /usr/src/app                                                                                                                         0.1s
 => [4/5] RUN npm install -g @angular/cli                                                                                                            20.1s
 => [5/5] RUN npm install                                                                                                                            13.8s
 => exporting to image                                                                                                                                4.0s
 => => exporting layers                                                                                                                               4.0s
 => => writing image sha256:e6b87cf9530701fe49f487780093e6bd0e87c2052147750debf8fdf3e6544851                                                          0.0s
 => => naming to docker.io/library/angular-docker-amazon-ecs Next, we will create the image tag. 7. docker tag angular-docker-amazon-ecs:latest public.ecr.aws/d3o6w2v8/angular-docker-amazon-ecs:latest Then, we will push the Docker image to the repository. 8. docker push public.ecr.aws/d3o6w2v8/angular-docker-amazon-ecs:latest
The push refers to repository [public.ecr.aws/d3o6w2v8/angular-docker-amazon-ecs]
0d182ddaeba2: Pushed 
692f273c8005: Pushed 
f19fda91d840: Pushed 
118d5d6c8a47: Pushed 
6ac923e38b05: Pushed 
18ffdcddf862: Pushed 
aab2cca0cf91: Pushed 
d4fc045c9e3a: Pushed 
latest: digest: sha256:2f09379b02c2669c915fc63116536d1bb5040c3d608a68b8f3306f10af4d125d size: 2000 Note: The AWS CLI user must have the permission . AmazonElasticContainerRegistryPublicFullAccess After pushing the Docker image to the repository, we will check if the Docker image was pushed to the repository. We will go back to the site and click on the repository name. 9. Now we will see the Docker image pushed. 10. Ready! The Docker image of the Angular application was pushed to the repository on Amazon ECR. 11. Create the conteiner on Amazon ECS Amazon ECS is a Docker containers orchestration service that enables you to deploy, manage, and scale containerized applications. Let's type in the search field and click on the option . 1. ECS Elastic Container Service Now we will click on the button . 2. Create cluster Next, we will fill in the field , click on the option , select the option in the field , select the option in the field , fill in the field , select the option in the field and click on the button . 3. Cluster name Amazon EC2 instances Amazon Linux 2 Operating system/Architecture c1.medium EC2 instance type Maximum Turn on Auto-assign public IP Create Then, we will click on the menu . 4. Task Definitions After click on the menu , we will click on the button . 5. Task definitions Create new task definition Now we will fill in the field , click on the option , select the option in the field , fill in the field , fill in the field , fill in the field with the tag name, fill in the field with the Docker image name, fill in the field with the external port, fill in the field with the NGINX port and click on the button . 6. Task definition family Amazon EC2 instances default Network mode CPU Memory Name Image URI Host port Container port Create Next, we will click on the button and click on the option . 7. Deploy Run task Then, we will click on the button because the fields , and were filled in. 8. Create Existing cluster Family, Revision After clicking on the button , we will wait for the EC2 instance to be created in the session . 9. Create Tasks Now we will type in the search field and click on the option . 10. ec2 EC2 Next, we will click on the menu . 11. Instances Then, we will click on the created instance. 12. After clicking on the created instance, we will click on the icon to copy the domain in . 13. Public IPv4 DNS Now we will access the URL in a browser. 14. http://ec2-54-146-190-174.compute-1.amazonaws.com Ready! The Docker image of the Angular application was deployed and the application is working. 15. Conclusion Summarizing what was covered in this article: We created a public repository on Amazon ECR. We changed the Docker configuration of the Angular application. We created the NGINX configuration file in the Angular application. We created a Docker image. We pushed the Docker image to the repository. We created a container on Amazon ECS for the deployment. We tested the Angular application inside the Docker container served on EC2 instance. You can use this article to create a Docker container with an Angular application image, push the image to a repository on Amazon ECR and deploy the container using Amazon ECS to an EC2 instance where the Angular application will be served. Thank you for reading and I hope you enjoyed the article! This tutorial was originally posted on my in Portuguese. blog To stay updated whenever I post new articles, follow me on and . Twitter LinkedIn

How To Host an Angular Application in a Docker Container on Amazon EC2 and Deploy It With Amazon ECS

Recently, Ethereum founder Vitalik Buterin proposed integrating (ZK-EVM) into Ethereum's Layer-1. This proposal is aimed at creating a native system within the Ethereum protocol that utilizes Zero-Knowledge Proofs for the verification of Ethereum blocks. an enshrined Zero-Knowledge Ethereum Virtual Machine The primary objective of integrating ZK-EVM into Ethereum's core is to reduce the blockchain's dependence on external codebases, potentially lowering the risks associated with bugs in these systems. The proposal suggests that incorporating ZK-EVM at the protocol level could improve Ethereum's network operations' security and processing speed. The idea of "enshrining" ZK-EVM within Ethereum's protocol is significant because it represents a structural enhancement to the blockchain's framework. The proposal aims to bolster the network's efficiency and security capabilities by making ZK-EVM a core component of Ethereum. This integration is also aligned with Ethereum's multi-client philosophy, which supports the use of various proving systems across different clients. The enshrinement of ZK-EVM is presented as a strategic update to Ethereum's infrastructure, designed to address scalability, privacy, and efficiency challenges, thereby supporting Ethereum's growth and adaptation to future demands. An example of a ZK-VM is the Polygon zkEVM, a bit like a turbo-charged engine for blockchain apps, designed to work with Ethereum but faster and cheaper. It's a kind of virtual machine that uses something called zero-knowledge proofs to process transactions. These proofs help speed things up and cut costs, all while keeping the rock-solid security Ethereum is known for. Under the hood, Polygon zkEVM uses a combination of two technologies, SNARKs and STARKs, to make things efficient and speedy. SNARKs help make the data smaller, which is great for saving space and costs, while STARKs speed up the process of proving that transactions are legit. By running several of these proof generators simultaneously, Polygon zkEVM can handle many more transactions at once, making the whole system faster and smoother for everyone. Another example is Linea, a Type 2 zkEVM with full EVM equivalence that enables compatibility with most of Ethereum's decentralized applications (DApps). Consequently, developers can port their DApps from Ethereum to Linea without extensive modifications. This compatibility extends to the ease of migrating code back to Ethereum or to other EVM-compatible blockchains, emphasizing Linea's adaptability and interoperability within the broader blockchain ecosystem. Since it is EVM-equivalent, it operates similarly to Ethereum's mainnet, providing a platform for developers to create and use smart contracts in an environment they are already familiar with. This similarity is designed to facilitate the transition for developers accustomed to Ethereum, enabling them to utilize Linea without significant adjustments to their workflow. The Developer Exodus to EVM Chains Electric Capital's latest report sheds light on a fascinating shift happening in the blockchain world: a huge number of developers are flocking to Ethereum Virtual Machine (EVM)-compatible chains. The report reveals a staggering fact - This shows how EVM chains are a magnet for developer talent and points to a significant change in where developers choose to spend their time and energy. 87% of all multichain developers have worked on at least one EVM-compatible network. The report also discusses a cool trend of "cross-pollination" among developers. A big chunk of them are not just sticking to one but are spreading their ideas and code across different EVM-compatible chains. The EVM ecosystem is where they want to be. So, what's pulling developers towards EVM chains? A few big reasons stand out. For starters, these chains gel well with Ethereum's standards and protocols, making it easy for developers to jump in without skipping a beat. They can use what they already know and what they've already built, cutting down on the time and effort needed to get up to speed. For example, the EOS EVM works as a bridge between the EOS and Ethereum ecosystems, letting developers bring over Solidity-based projects—think digital assets and dApps—from Ethereum into the high-speed, high-efficiency world of EOS. It's like taking the best of both worlds: Ethereum's rich ecosystem and mature tools, and combining them with the power-packed performance EOS is known for. The EVM also supports WebSocket a tool for developing applications that need to talk back and forth with the server in real-time, without the delay you'd typically get with regular HTTP requests. This means developers can build more responsive and interactive applications directly on the EOS EVM, from chat apps and live trading platforms to DeFi notifications and NFT mint tracking. Then there's the toolbox and community support with Ethereum and its kin. Developers can access everything from top-notch documentation to ready-made smart contract templates and forums full of fellow coding enthusiasts. This wealth of resources makes it a breeze to build, experiment, and innovate. But it's not just about the ease of use. Cost and scalability are huge, too. With Ethereum's gas fees sometimes hitting the roof, developers are looking for places to build without burning through cash. EVM-compatible chains often offer a sweet spot of lower costs and higher performance, making them super appealing for anyone wanting to deploy dApps or smart contracts. Plus, the rise of layer-2 solutions and sidechains means even better scalability and affordability, all while staying friendly with Ethereum's ecosystem. Real-life stories of projects making the move to EVM chains are everywhere. Take Polygon and Binance Smart Chain, which have become hotspots for everything from DeFi projects to NFT marketplaces. Developers behind these moves often talk about how the switch made sense for them in terms of deployment ease, cost savings, and reaching a wider audience. Hearing from developers themselves, it's clear they're thinking strategically. They're not just chasing the next big thing; they're looking for platforms that offer the best mix of tech savvy, economic sense, and audience reach. This shift to EVM-compatible chains isn't just a trend. It's a calculated move by developers aiming to maximize the blockchain's potential, focusing on efficiency, scalability, and the chance to connect with more users. The Rising Adoption of EVM as a Cost-Effective Alternative Flipside, a platform diving deep into blockchain data, as a wallet-friendly choice in the blockchain world. They've noticed a big trend: people and developers are leaning more towards EVM-compatible layer-2 networks. has shed light on how the Ethereum Virtual Machine (EVM) is gaining traction Searching for cheaper transaction costs and quicker processing times mainly drives this move. Given Ethereum's own struggles with sky-high gas fees and jam-packed networks, it's no surprise that folks are looking for smoother options. Flipside's findings suggest this isn't just a fleeting trend. It looks like we're witnessing a shift that could really shake up the market, pushing towards alternatives to Ethereum. The push for EVM-compatible options is part of a larger movement in the industry, where keeping costs down and boosting performance is key. New players and ecosystems might enter the scene as developers and users flock to platforms that strike the correct balance between cost efficiency and performance. This could lead to a more diverse blockchain ecosystem, with various chains and layer-2 solutions living side by side, offering more choices to developers and users alike. The landscape for EVM chains and Ethereum seems set for continuous evolution, with upgrades aimed at tackling scalability and affordability. How EVM-compatible chains fit into this picture will likely shift as these improvements roll out. Aspects like environmental impact, governance, and how well different systems work together will take on bigger roles as the ecosystem grows. Moreover, the ability for Ethereum and EVM-compatible chains to work seamlessly together will be vital for a cohesive blockchain ecosystem that doesn't sacrifice security or the spirit of decentralization for efficiency and user experience. Flipside's insights into the EVM's rise as a budget-friendly alternative highlight a significant moment for the blockchain industry. This trend is shaking up the competitive landscape and fuelling innovation, possibly leading to the birth of new platforms and ecosystems. As the blockchain space continues to unfold, the importance of sustainability, governance, and interoperability in shaping the future success of EVM chains and Ethereum will only grow. These trends paint a picture of a blockchain future where adaptability, efficiency, and inclusivity are front and center. Conclusion The Ethereum and its underlying technology, the Ethereum Virtual Machine (EVM), is undergoing some pretty exciting changes. It's a time full of opportunities for developers, investors, and anyone passionate about blockchain. As more chains become compatible with EVM and innovations keep popping up within Ethereum itself, we're seeing a sector that's growing fast and opening new doors for exploration, development, and investment. The expanding EVM ecosystem is like a vast playground for the tech wizards out there. Innovations like ZK-EVM are making Ethereum more scalable and private, making it an even better place for developing decentralized apps. Whether you're into creating the next big DeFi platform, crafting unique NFT experiences, or pushing the boundaries with new blockchain apps, now's the time to dive in. The community's strong, the tools and endless possibilities exist. Investors, you're up for an exciting ride too. Electric Capital and Flipside reports show a surge of interest in EVM-compatible solutions. This buzz is creating a fertile ground for investments that could pay off big time down the line. It's a good moment to look into projects and platforms within the EVM ecosystem, as your investments could help shape the future of decentralized tech. And let's not forget the blockchain enthusiasts – your voice matters more than ever. Getting involved in governance, joining the conversation in community forums, or spreading the latest in EVM tech can make a real difference. These collective actions will help push the ecosystem to be more open, inclusive, and true to the spirit of decentralization.

EVMs in 2024: Vitalik's ZK-EVM Proposal and the Developer Shift to EVM Chains

The ) is crucial to the whole Ethereum system. Think of it as a virtual computer, unlike your regular laptop. Instead, it's distributed across tons of computers in the Ethereum network. This setup makes it super tough for anyone to control or mess with. Ethereum Virtual Machine (EVM Now, why does it matter so much? Well, the EVM is like the heart of Ethereum. It's where all the action happens. It runs these things called "smart contracts." They're like self-operating bits of code that can do all sorts of stuff, from simple tasks to running entire decentralized apps (DApps). The EVM ensures they run properly, without any middlemen, and in a way, everyone in the network agrees. So, when you send a transaction that involves a smart contract on Ethereum, the EVM kicks into action. It processes and runs the code in that contract. And believe me, these contracts can be pretty complex. But no matter what, the EVM makes sure they run securely and in the same way on all the computers in the network. Now, here's the cool part. The EVM uses Ether (ETH), Ethereum's cryptocurrency, to pay for the computing power it needs. So, when you run a smart contract, you're paying for its computer resources. This helps keep things fair and discourages spam and bad behavior. Here we are going to explore five different EVMs. This detailed look at EVMs promises to deliver essential insights into the heart of this ground-breaking technology, whether you're a blockchain enthusiast, developer, or just curious about the evolution of Ethereum. This is not a list in any particular order, but rather a summary of five separate EVM protocols. The author acknowledges a vested interest in the organization(s) highlighted in this story. However, the views expressed within are delivered impartially and without bias. Disclosure: EOS EVM EOS EVM (EOS Ethereum Virtual Machine) is a significant development within the Antelope (formerly known as EOSIO) blockchain ecosystem, designed to bring Ethereum compatibility to the EOS platform. EOS EVM bridges the gap between these platforms by implementing an Ethereum Virtual Machine within the Antelope ecosystem. This means that developers can deploy and execute Ethereum-compatible smart contracts on Antelope-based blockchains, expanding the capabilities of EOS. One of the core components of EOS EVM is the Ethereum Virtual Machine itself. It's a crucial part of the Ethereum network, processing transactions and running decentralized applications. By incorporating EVM into Antelope, developers can leverage the vast Ethereum developer community and the multitude of existing Ethereum DApps and tools. The Ethereum Virtual Machine is a runtime environment where smart contracts are executed. Due to this, developers can deploy Ethereum-based smart contracts on Antelope blockchains, benefiting from the scalability and performance improvements inherent in Antelope technology. This can be especially appealing for developers who want to take advantage of Antelope's fast transaction speeds and low fees while still being able to use their Ethereum-based code. EOS EVM also supports Ethereum's native programming languages, such as Solidity, and integrates with Ethereum development tools like Truffle and Remix. This minimizes the learning curve for Ethereum developers looking to migrate or build on Antelope, as they can continue to use their familiar tools and languages. With the implementation of EOS EVM v0.6.0 which is now live, EOS Native and EOS EVM can now establish communication without any issues. This development enables EOS and EOS Native's USDT to use the trustless bridge, converting it into an ERC-20 token on the EOS EVM platform. Furthermore, the EOS EVM v0.6.0 update introduces "call action" and "bridge messages," enhancing the functionality of the Trustless Bridge. These additions open up new possibilities, such as ERC-20 token bridging, cross-chain trading, oracles, DEX aggregation, and more. Another noteworthy feature of EOS EVM is its ability to interact seamlessly with other Antelope-based assets and applications. This means that tokens, NFTs (Non-Fungible Tokens), and other assets created within the EOS ecosystem can be used in conjunction with Ethereum-compatible smart contracts, offering a wide range of possibilities for decentralized applications. Polygon zkEVM Polygon zkEVM is a Layer 2 (L2) scaling solution designed to enhance the Ethereum network's performance by leveraging zero-knowledge (ZK) proofs. The protocol aims to maintain compatibility with Ethereum while using ZK technology. Polygon zkEVM uses the Proof-of-Efficiency (PoE) that focuses on creating batches of transactions. To understand how it works, let's break it down into two key steps involving different participants: the Sequencer and the Aggregator. Step 1: The Sequencer In the first step of this process, we have the Sequencer. Think of them as the initiators of the batch creation. They play a crucial role by collecting various transactions or activities from users within the blockchain network. These transactions involve anything from simple payments to more complex smart contract interactions. The Sequencer's job is to organize these activities meaningfully and efficiently. They ensure that transactions are sequenced correctly, which is essential for the smooth functioning of the blockchain. Step 2: The Aggregator Let's move on to the second party involved – the Aggregator. Once the Sequencer has organized the transactions, it's the Aggregator's turn to step in. Their role is to take the sequenced activities and bundle them into batches. This batching process is significant for optimizing the blockchain's performance. By grouping transactions, the Aggregator reduces the overall workload on the network and enhances its efficiency. What's neat about zkEVM is that it allows you to deploy your applications on the Ethereum Virtual Machine without changing your existing code. So, if you've already got smart contracts or dapps set up on Ethereum, you can transition them to zkEVM without starting from scratch. This saves a lot of time and effort for developers. In terms of security, Polygon zkEVM inherits some of the strong security features from Ethereum and adds another layer of protection. ZK proofs are used to ensure transactions are valid and keep user funds safe. Plus, it ensures that the data stored on the blockchain can't be tampered with or corrupted. zkSync Era zkSync is a layer-2 scaling solution specifically designed to address the scalability and cost-related challenges faced by the Ethereum network, rather than seeking to replace the Ethereum Virtual Machine (EVM), zkSync functions in tandem with it, offering a complementary approach to enhancing the overall Ethereum ecosystem. One of the fundamental ways zkSync contributes to Ethereum's scalability is by offloading transactions from the Ethereum mainnet. When users intend to interact with smart contracts or initiate transactions using zkSync, they divert these actions to the zkSync network instead of overloading the Ethereum mainnet. This approach ensures that these transactions are processed off-chain, relieving the EVM of high gas fees and slow confirmation times. Crucially, zkSync employs Zero-Knowledge Proofs, a cryptographic technique, to verify the validity of transactions and smart contract executions without disclosing sensitive details on the Ethereum mainnet. Periodically, zkSync aggregates transactions and submits a concise proof to the Ethereum network, certifying the legitimacy of the transactions conducted on zkSync. This mechanism bolsters security and maintains decentralization by anchoring zkSync's state securely within the Ethereum ecosystem. Developers can continue to write and deploy smart contracts on the EVM just as they would conventionally, without needing to adapt their workflows. Users can interact with these contracts using zkSync, leveraging its enhanced performance and cost-efficiency. This interoperability ensures that ) can operate as usual while reaping the advantages zkSync brings to the table, thus preserving the user experience while improving the overall efficiency of the Ethereum network. decentralized applications (DApps Scroll Scroll is a zk-rollup project to become an EVM-compatible zkEVM. One of the protocol's main technologies is polynomial commitment, specifically the KZG polynomial commitment method, to streamline the generation of zero-knowledge proofs. This method improves the effectiveness of the ZK-Rollup procedure while decreasing the amount of computing power required. Additionally, Scroll explores hardware acceleration options, including GPU, FPGA, and ASIC, to further optimize the generation of zero-knowledge proofs. Scroll's infrastructure comprises key components that enable its ZK-Rollup network. The Scroll Node plays a central role in managing the transaction lifecycle. Three specific roles within the Scroll Node are crucial for its operation. The Sequencer processes incoming transactions, grouping and executing them to compose blocks. The Coordinator detects new block creation, receives execution traces from the Sequencer, and selects a Roller from the specialized Roller Network for generating zero-knowledge proofs (ZKPs). The Relayer oversees network monitoring and verifies the submission of roll-up blocks and validation proofs on Ethereum. It also manages deposit and withdrawal events in the bridge contract, facilitating seamless fund transfers between networks. The Roller Network specializes in generating ZKPs, a fundamental aspect of Scroll's ZK-Rollup solution. Its use of advanced hardware acceleration technologies like GPUs, FPGAs, and ASICs, and optimizing ZKP generation for improved network performance is what sets it apart. Rollers receive execution trace data from the Scroll Node's Coordinator and convert it into circuit witnesses to create ZKPs, demonstrating the validity of specific transaction blocks. These ZKPs are aggregated into a single block proof to enhance scalability and ensure the entire block's integrity. The Rollup and Bridge Contracts facilitate data and fund transfers between Scroll and Ethereum. The Rollup Contract stores state roots summarizing Scroll's network state and block data from the Sequencer. It verifies validation proofs from Rollers, maintaining network integrity. The Bridge Contract manages asset transfers between the two networks, continuously monitored by the Relayer, ensuring smooth asset movement. Looking ahead, Scroll aims to be fully decentralized, including decentralizing the sequencer and roller roles. While the project is currently in the pre-alpha testnet phase, it has a roadmap that includes an alpha testnet stage before the mainnet launch. The ultimate goal is to provide a ZK-Rollup solution that achieves the highest level of EVM compatibility and contributes to the scalability and decentralization of the Ethereum ecosystem. Linea Linea is a zero-knowledge Since Linea is EVM-equivalent, it's like a copy of Ethereum's mainnet but with some exciting advantages. The protocol provides developers a familiar space to create and deploy smart contracts, same as how they would work on the Ethereum network. Ethereum Virtual Machine (zkEVM) built by ConsenSys. In other words, Linea gives developers the freedom to build and experiment, all while enjoying the security and features of the Ethereum ecosystem. Linea is classified as a Type 2 zkEVM chain, following the classification coined by Ethereum's founder, Vitalik Buterin. This classification tells us that Linea closely resembles Ethereum in terms of its functionality and capabilities. It's like a sibling of Ethereum, sharing many of the same characteristics. One of Linea's main benefits is reducing transaction costs while increasing throughput. As a result, Linea provides a more economical and efficient platform for executing and processing smart contracts and transactions than Ethereum's mainnet. Similar to Ethereum, but without the overhead and high petrol prices. Because Linea is a fully EVM equivalent zkEVM, it's compatible with almost all Ethereum DApps (decentralized applications). This means that developers and protocols can seamlessly migrate their code from Ethereum to Linea without needing to rewrite or audit everything all over again. It is also simple for developers to re-deploy their code from Linea to Ethereum or any other blockchain compatible with the Ethereum Virtual Machine (EVM). Linea was created with adaptability in mind. Looking forward Understanding the Ethereum Virtual Machine is beneficial for developers within the Ethereum ecosystem. The EVM serves as the bedrock upon which Ethereum's smart contracts and decentralized applications (DApps) are built. Regardless of the specific EVM-compatible solution being used, developers should strive for a profound comprehension of how the EVM operates. This knowledge is the cornerstone for creating and deploying smart contracts effectively, ensuring their functionality and security. There is great value in being an active member of useful online communities, discussions, and social media groups. Engaging with the blockchain community keeps you informed about the latest developments in EVM and EVM-compatible technologies. It also provides opportunities for learning from peers, sharing knowledge, and networking, fostering growth and adaptability in a constantly evolving blockchain landscape. The blockchain world is a constantly evolving labyrinth, and adaptability, combined with a commitment to staying informed, is the compass that guides developers and users alike. By staying informed about Ethereum's evolution, exploring scaling and cryptographic solutions, ensuring security and compatibility, seeking interoperability opportunities, and actively participating in the community, you can confidently navigate the dynamic crypto realm and make judicious decisions for your projects.

Examining 5 Ethereum Virtual Machines (EVMs) Up Close

EVE'S DIARY

The Noonification: Guide On ECS (Entity-Component-System) In Unity: Part 2 (8/19/2023)

The Noonification: Exploring Unity DOTS and ECS: Is it a Game Changer? (7/18/2023)

Unity DOTS allows developers to use the full potential of modern processors and deliver highly optimized, efficient games – and we think it’s worth paying attention to. It’s been over five years since Unity first announced development of their Data-Oriented Technology Stack (DOTS). Now, with the release of Unity 2023.3.0f1, we’ve finally seen an official release. But why is Unity DOTS so critical to the game development industry, and what advantages does this technology offer? Hello, everyone! My name is Denis Kondratev, and I'm a Developer at MY.GAMES. If you've been eager to understand what Unity DOTS is and whether it's worth exploring, this is the perfect opportunity to delve into this fascinating topic, and in this article – we’ll do just that. Unity What is the Entity Component System (ECS)? At its core, DOTS implements the Entity Component System (ECS) architectural pattern. To simplify this concept, let’s describe it like this: ECS is built upon three fundamental elements: Entities, Components, and Systems. , on their own, lack any inherent functionality or description. Instead, they serve as containers for various Components, which bestow them with specific characteristics for game logic, object rendering, sound effects, and more. Entities , in turn, come in different types and just store data without independent processing capabilities of their own. Components Completing the ECS framework are , which process Components, handle Entity creation and destruction, and manage the addition or removal of Components. Systems For instance, when creating a "Space Shooter" game, the playground will feature multiple objects: the player's spaceship, enemies, asteroids, loot, you name it. All of these objects are considered entities in their own right, devoid of any distinct features. However, by assigning different components to them, we can imbue them with unique attributes. To demonstrate, considering that all these objects possess positions on the game field, we can create a position component that holds the object's coordinates. Furthermore, for the player's spaceship, enemies, and asteroids, we can incorporate health components; the system responsible for handling object collisions will govern the health of these entities. Additionally, we can attach an enemy type component to the enemies, enabling the enemy control system to govern their behavior based on their assigned type. While this explanation provides a simplistic, rudimentary overview, the reality is somewhat more complex. Nonetheless, I trust that the fundamental concept of ECS is clear. With that out of the way, let's delve into the advantages of this approach. The benefits of the Entity Component System One of the main advantages of the Entity Component System (ECS) approach is the architectural design it promotes. (OOP) carries a significant legacy with patterns like inheritance and encapsulation, and even experienced programmers can make architectural mistakes in the heat of development, leading to refactoring or tangled logic in long-term projects. Object-oriented programming In contrast, ECS provides a simple and intuitive architecture. Everything falls naturally into isolated components and systems, making it easier to understand and develop using this approach; even novice developers quickly grasp this approach with minimal errors. ECS follows a composite approach, where isolated components and behavior systems are created instead of complex inheritance hierarchies. These components and systems can be easily added or removed, allowing for flexible changes to entity characteristics and behavior – this approach greatly enhances code reusability. Another key advantage of ECS is performance optimization. In ECS, data is stored in memory in a contiguous and optimized manner, with identical data types placed close to each other. This optimizes data access, reduces cache misses, and improves memory access patterns. Moreover, systems composed of separate data blocks are easier to parallelize across different processes, leading to exceptional performance gains compared to traditional approaches. Exploring the packages of Unity DOTS Unity DOTS encompasses a set of technologies provided by Unity Technologies that implement the ECS concept in Unity. It includes several packages designed to enhance different aspects of game development; let’s cover a few of those now. The core of DOTS is the package, which facilitates the transition from familiar MonoBehaviours and GameObjects to the Entity Component System approach. This package forms the foundation of DOTS-based development. Entities The package introduces a new approach to handling physics in games, achieving remarkable speed through parallelized computations. Unity Physics Additionally, the package allows integration with the modern Havok Physics engine. This engine offers high-performance collision detection and physical simulation, powering popular games such as The Legend of Zelda: Breath of the Wild, Doom Eternal, Death Stranding, Mortal Kombat 11, and more. Havok Physics for Unity The package focuses on rendering in DOTS. It enables efficient gathering of rendering data and works seamlessly with existing render pipelines like the Universal Render Pipeline (URP) or High Definition Render Pipeline (HDRP). Entities Graphics One more thing, Unity has also been actively developing a networking technology called Netcode. It includes packages like Unity Transport for low-level multiplayer game development, Netcode for GameObjects for traditional approaches, and the noteworthy package, which aligns with DOTS principles. These packages are relatively new and will continue to evolve in the future. Unity Netcode for Entities Enhancing performance in Unity DOTS and beyond Several technologies closely related to DOTS can be used within the DOTS framework and beyond. The package provides a convenient way to write code with parallel computations. It revolves around dividing work into small chunks called jobs, which perform computations on their own data. The Job System evenly distributes these jobs across threads for efficient execution. Job System To ensure code safety, the Job System supports the processing of blittable data types. Blittable data types have the same representation in managed and unmanaged memory and require no conversion when passed between managed and unmanaged code. Examples of blittable types include byte, sbyte, short, ushort, int, uint, long, ulong, float, double, IntPtr, and UIntPtr. One-dimensional arrays of blittable primitive types and structures containing exclusively blittable types are also considered blittable. However, types containing a variable array of blittable types are not considered blittable themselves. To address this limitation, Unity has developed the package, which provides a set of unmanaged data structures for use in jobs. These collections are structured and store data in unmanaged memory using Unity mechanisms. It is the developer's responsibility to deallocate these collections using the Disposal() method. Collections Another important package is the , which can be used with the Job System to generate highly optimized code. Although it comes with certain code usage limitations, the Burst compiler provides a significant performance boost. Burst Compiler Measuring performance with Job System and Burst Compile As mentioned, Job System and Burst Compiler are not direct components of DOTS but provide valuable assistance in programming efficient and fast parallel computations. Let's test their capabilities using a practical example: implementing . In this algorithm, a field is divided into cells, each of which can be either alive or dead. During each turn, we check the number of live neighbors for each cell, and their states are updated according to specific rules. Conway's Game of Life algorithm Here’s the implementation of this algorithm using the traditional approach: private void SimulateStep()
{
    Profiler.BeginSample(nameof(SimulateStep));
    
    for (var i = 0; i < width; i++)
    {
        for (var j = 0; j < height; j++)
        {
            var aliveNeighbours = CountAliveNeighbours(i, j);
            var index = i * height + j;

             var isAlive = aliveNeighbours switch
            {
                2 => _cellStates[index],
                3 => true,
                _ => false
            };

             _tempResults[index] = isAlive;
        }
    }
    
    _tempResults.CopyTo(_cellStates);
    Profiler.EndSample();
}

private int CountAliveNeighbours(int x, int y)
{
    var count = 0;
    
    for (var i = x - 1; i <= x + 1; i++)
    {
        if (i < 0 || i >= width) continue;
        
        for (var j = y - 1; j <= y + 1; j++)
        {
            if (j < 0 || j >= height) continue;

            if (_cellStates[i * width + j])
            {
                count++;
            }
        }
    }

    return count;
} I’ve added markers to Profiler to measure the time taken for the calculations. The states of the cells are stored in a one-dimensional array called . We initially write the temporary results to and then copy them back to upon completing the calculations. This approach is necessary because writing the final result directly to would affect subsequent calculations. _cellStates _tempResults _cellStates _cellStates I created a field of 1000x1000 cells and ran the program to measure the performance. Here are the results: As seen from the results, the calculations took 380 ms. Now let's apply the Job System and Burst Compiler to improve the performance. First, we will create the Job responsible for executing the Conway's Game of Life algorithm. public struct SimulationJob : IJobParallelFor
{
    public int Width;
    public int Height;
    [ReadOnly] public NativeArray<bool> CellStates;
    [WriteOnly] public NativeArray<bool> TempResults;

    public void Execute(int index)
    {
        var i = index / Height;
        var j = index % Height;
        var aliveNeighbours = CountAliveNeighbours(i, j);

        var isAlive = aliveNeighbours switch
        {
            2 => CellStates[index],
            3 => true,
            _ => false
        };

        TempResults[index] = isAlive;
    }
    
    private int CountAliveNeighbours(int x, int y)
    {
        var count = 0;
    
        for (var i = x - 1; i <= x + 1; i++)
        {
            if (i < 0 || i >= Width) continue;
        
            for (var j = y - 1; j <= y + 1; j++)
            {
                if (j < 0 || j >= Height) continue;

                if (CellStates[i * Width + j])
                {
                    count++;
                }
            }
        }

        return count;
    }
} I have assigned the attribute to the field, allowing unrestricted access to all values of the array from any thread. However, for the field, which has the attribute, writing can only be done through the index specified in the method. Attempting to write a value to a different index will generate a warning. This ensures data safety when working in a multi-threaded mode. [ReadOnly] CellStates TempResults [WriteOnly] Execute(int index) Now, from the regular code, let's launch our Job: private void SimulateStepWithJob()
{
    Profiler.BeginSample(nameof(SimulateStepWithJob));

    var job = new SimulationJob
    {
        Width = width,
        Height = height,
        CellStates = _cellStates,
        TempResults = _tempResults
    };

    var jobHandler = job.Schedule(width * height, 4);
    jobHandler.Complete();
    job.TempResults.CopyTo(_cellStates);
    Profiler.EndSample();
} After copying all the necessary data, we schedule the execution of the job using the method. It's important to note that this scheduling doesn't immediately execute the calculations: these actions are initiated from the main thread, and the execution happens through workers distributed among different threads. To wait for the job to complete, we use . Only then can we copy the obtained result back to . Schedule() jobHandler.Complete() _cellStates Let's measure the speed: The execution speed has increased almost tenfold, and the execution time is now approximately 42 ms. In the Profiler window, we can see that the workload was distributed among 17 workers. This number is slightly less than the number of processor threads in the test environment, which is an Intel® Core™ i9-10900 with 10 cores and 20 threads. While the results may vary on processors with fewer cores, we can ensure the full utilization of the processor's power. But that's not all – it's time to utilize Burst Compiler, which provides significant code optimization but comes with certain restrictions. To enable Burst Compiler, simply add the attribute to the . [BurstCompile] SimulationJob [BurstCompile]
public struct SimulationJob : IJobParallelFor
{
    ...
} Let's measure again: The results exceed even the most optimistic expectations: speed has increased almost 200 times compared to the initial result. Now, the computation time for 1 million cells is no more than 2 ms. In Profiler, the parts executed by the code compiled with the Burst Compiler are highlighted in green. Conclusion While the use of multithreaded computations may not always be necessary, and the utilization of Burst Compiler may not always be possible, we can observe a common trend in processor development toward multi-core architectures. This means that we should be prepared to harness their full power. ECS, and specifically Unity DOTS, align perfectly with this paradigm. I believe that Unity DOTS deserves attention, at the very least. While it may not be the best solution for every case, ECS can prove its worth in many games. The Unity DOTS framework, with its data-oriented and multithreaded approach, offers tremendous potential for optimizing performance in Unity games. By adopting the Entity Component System architecture and leveraging technologies like the Job System and Burst Compiler, developers can unlock new levels of performance and scalability. As game development continues to evolve and hardware advances, embracing Unity DOTS becomes increasingly valuable. It empowers developers to harness the full potential of modern processors and deliver highly optimized and efficient games. While Unity DOTS may not be the ideal solution for every project, it undoubtedly holds immense promise for those seeking performance-driven development and scalability. Unity DOTS is a powerful framework that can significantly benefit game developers by enhancing performance, enabling parallel computations, and embracing the future of multi-core processing. It’s worth exploring and considering its adoption to fully leverage modern hardware and optimize the performance of Unity games.

Stories, News & Mentions about EVCS

Evcs’s Stories on HackerNoon