Coding & Development

AS-One is a comprehensive, open-source Python wrapper designed for computer vision tasks, providing an easy and modular interface for object detection, segmentation, tracking, and pose estimation. It supports a wide range of YOLO models, including YOLOv9, v8, v7, v6, v5, R, and X, enabling users to implement these advanced models in under 10 lines of code. The library integrates various tracking algorithms like ByteTrack, DeepSORT, and NorFair, and supports models in ONNX, PyTorch, and CoreML formats. AS-One also includes capabilities for text detection and recognition using models like CRAFT and EasyOCR, and pose estimation with YOLOv8 and YOLOv7-w6. It is ideal for developers and researchers looking for a unified and efficient solution for their computer vision projects.

OWASP dep-scan is a comprehensive security and risk audit tool designed to analyze project dependencies for known vulnerabilities, advisories, and license limitations. It supports scanning both local code repositories and container images, making it versatile for various development workflows. The tool is highly suitable for integration with Application Security Posture Management (ASPM) and Vulnerability Management (VM) platforms, as well as within Continuous Integration (CI) environments. Key features include advanced reachability analysis for multiple languages, local and fast package vulnerability scanning, and the generation of Software Bill-of-Materials (SBOM) with Vulnerability Disclosure Report (VDR) information. It also performs deep package risk audits for dependency confusion attacks and maintenance risks, providing clear insights into CVEs and automatic prioritization.

ECA (Editor Code Assistant) is an AI-powered pair programming tool designed to streamline the coding process. It offers intelligent code assistance, including features like code completion and suggestions, to help developers write code more efficiently. A key aspect of ECA is its editor-agnostic design, allowing it to integrate seamlessly with a wide range of code editors. This open-source project aims to improve developer productivity by providing smart, context-aware coding support.

Emgo is an open-source project that provides a compiler and a set of packages for running Go programs on small 32-bit microcontrollers. It functions by generating C as an intermediate code, which is then compiled by a C compiler to produce loadable binaries. While the main development has shifted to Embedded Go for higher hardware compatibility, Emgo remains valuable for smaller MCUs. It supports ARM Cortex-M based MCUs and requires the Go compiler and ARM embedded toolchain for setup. The project includes examples and helper scripts for building, loading, and debugging programs on development boards like STM32 Nucleo.

FastDepth is an open-source project that provides trained models and evaluation code for fast monocular depth estimation, specifically optimized for embedded systems. The project includes resources for setting up the environment, downloading pre-trained models, evaluating performance, and deploying models on hardware like the NVIDIA Jetson TX2. It leverages PyTorch for model training and evaluation, and the TVM compiler stack for efficient cross-compilation and deployment. The repository offers various MobileNet-NNConv5 architectures, including pruned versions with additive skip connections, demonstrating significant performance improvements in terms of RMSE and delta1 metrics compared to prior work, with very low runtimes on embedded GPUs.

FrostDB is an embeddable wide-column columnar database written in Go, designed for analytical workloads where the majority of interactions are writes, with occasional analytical queries. It leverages Apache Parquet for efficient storage and Apache Arrow for vectorized query execution. A key differentiator is its support for dynamic columns, allowing schemas to evolve at runtime, which is particularly useful for observability data like Prometheus time-series. The database maintains data immutability and uses an LSM-like index for storage, with snapshot isolation for reads. While still in its infancy and not production-ready, FrostDB offers a compelling solution for Go developers needing an embedded, high-performance columnar database for immutable, semi-structured datasets.

frozen is a robust JSON parser and generator specifically designed for C/C++ applications, emphasizing efficiency and a minimal footprint. It offers a familiar scanf/printf-like interface for easy integration and use, making it particularly suitable for embedded systems where resources are often constrained. The tool is ISO C and ISO C++ compliant, ensuring broad compatibility. Key functionalities include `json_scanf()` for parsing JSON strings into C/C++ variables, `json_printf()` for generating JSON output, and `json_setf()` for modifying existing JSON strings. It also supports reading and writing JSON to files, and includes built-in base64 encoding/decoding. With 100% test coverage and no external dependencies, frozen provides a reliable and lightweight solution for JSON manipulation in performance-critical environments.

FigmaChain is an open-source tool comprising Python scripts designed to convert Figma designs into functional HTML/CSS code. It integrates with OpenAI's GPT-3 model to provide an AI-powered code generation capability, allowing developers to quickly translate visual designs into front-end code. The tool also features a Streamlit-based chatbot interface, enabling interactive code generation and a more user-friendly experience. It is available on GitHub, making it accessible for developers to use and contribute to.

LuaRadio is a lightweight and embeddable flow graph signal processing framework specifically designed for software-defined radio (SDR). Built on LuaJIT, it offers a small binary footprint and no external hard dependencies, making it highly portable. The framework provides a comprehensive suite of source, sink, and processing blocks, along with a simple API for defining and running flow graphs, creating custom blocks, and managing data types. It's ideal for rapidly prototyping software radios, developing modulation/demodulation utilities, and conducting signal processing experiments. LuaRadio can also be embedded into existing radio applications, serving as a user-scriptable engine for advanced signal processing tasks. It supports computational acceleration through LuaJIT's FFI to wrap external libraries like VOLK, liquid-dsp, and others, ensuring efficient performance.

llm-twin-course is a free educational resource designed to guide users through the process of building a production-ready Large Language Model (LLM) and Retrieval Augmented Generation (RAG) system. The course emphasizes LLMOps best practices, offering practical, hands-on lessons and accompanying source code. It covers the entire development lifecycle, from initial data gathering to the final stages of productionizing LLMs, with a specific focus on creating an AI replica.

microprofile is an embeddable profiler designed for C++ projects, offering robust capabilities for performance analysis and bottleneck identification. It integrates easily into existing codebases, requiring just a few lines to start profiling. Key features include CPU and GPU timing across multiple APIs like OpenGL, D3D11, D3D12, and Vulkan, as well as support for multithreaded renderers. The tool also provides counter tracking, a timeline view for longer-duration events, and a live web view for real-time monitoring and capture generation. A standout feature is dynamic instrumentation for Intel x86-64, allowing injection of markers into running code without recompilation, though it's noted as experimental. Captures can be compared, and the tool supports compressed captures using miniz to manage file sizes.

MY-BASIC is a lightweight BASIC interpreter implemented in standard C, provided in dual files for easy integration. It aims to be highly embeddable, extendable, and portable across various platforms. The interpreter supports dynamic typing, structured syntax, and a unique blend of prototype-based object-oriented programming with functional programming via lambda abstraction. Its core is compact, allowing it to be used as a standalone interpreter or seamlessly embedded into existing projects developed in C, C++, Java, Objective-C, Swift, C#, and more. Developers can customize its functionality by adding their own scripting interfaces, making it a versatile tool for various programming needs.

Nerves offers a comprehensive set of tools and libraries for developing and deploying embedded software using Elixir. It leverages the robust Erlang virtual machine and the Linux kernel to create small, self-contained software images for microprocessor-based systems. While not a full Linux distribution, Nerves integrates the Erlang runtime early in the boot process, allowing Elixir to manage the system. It supports a wide range of hardware, including various Raspberry Pi models and BeagleBone boards, and provides access to the Elixir ecosystem, including Phoenix, LiveView, Elixir Nx, and Livebook. Nerves also includes a C/C++ cross-toolchain for consistent builds across host platforms and offers modules for hardware access, networking, and SSH capabilities.

Richkware is a modern C++20 framework designed for building educational malware agents, offering a comprehensive, secure, and modular architecture. It enables users to understand malware mechanics and cybersecurity defense strategies through practical application. The framework features core capabilities like modern C++20 standards, memory safety, type safety, and thread safety. For security, it incorporates AES-256-GCM encryption, TLS 1.3 communications, and secure key derivation. System integration includes multi-method persistence, privilege management, and stealth operations. Advanced modules cover file management, keylogging, screenshot capabilities, process management, anti-analysis techniques, and self-deletion. Richkware is intended strictly for educational and research purposes, emphasizing ethical use and disclaiming responsibility for misuse.

ObjectDetection-OneStageDet is an open-source object detection framework developed by Tencent, designed to provide a unified platform for single-stage generic object detectors. Currently, it supports YOLOv2 and YOLOv3 implementations, with future plans to integrate YOLO and SSD into a single framework. The tool emphasizes performance and speed, offering good mAP scores and fast inference times, especially with various efficient backbones like TinyYOLO, MobileNet, and ShuffleNet. It provides comprehensive instructions for installation, data preparation, training, evaluation, and benchmarking, making it suitable for developers and researchers working on object detection tasks.

Flow-Guided Feature Aggregation (FGFA) is an open-source implementation for video object detection, initially described in an ICCV 2017 paper. It offers an accurate and end-to-end learning framework, significantly improving object detection accuracy in videos, particularly for fast-moving objects, by aggregating nearby frame features along motion paths. The tool is end-to-end trainable for video object detection and includes motion-specific evaluation code to assess detection accuracy for slow, medium, and fast-moving objects. This repository is based on MXNet and was developed by interns at MSRA, building upon previous work like Deep Feature Flow.

The Edinburgh Centre for Robotics (ECR) is a leading research and training institution dedicated to advancing Robotics and Autonomous Systems (RAS). It brings together over 50 world-leading investigators from Heriot-Watt University and the University of Edinburgh. The ECR focuses on research topics related to safety and safe interaction between robots, people, and their environments, applying fundamental theoretical methods to real-world problems. The center also hosts Centres for Doctoral Training (CDTs) in AI, robotics, and autonomous systems, including the UKRI AI CDT in Dependable and Deployable AI for Robotics (CDT-D2AIR). These programs aim to produce innovation-ready graduates equipped with technical, scientific, ethical, and enterprise skills, aligning closely with industrial project partners across various RAS market sectors.

Ring-Buffer is a straightforward and efficient ring buffer (circular buffer) implementation specifically tailored for embedded systems. It addresses the critical need for effective data management in environments with limited memory resources. The tool provides essential functions such as `ring_buffer_queue` for adding single characters, `ring_buffer_queue_arr` for adding arrays of characters, `ring_buffer_dequeue` for removing single characters, and `ring_buffer_dequeue_arr` for removing arrays. Additionally, it includes utilities like `ring_buffer_peek` to inspect data without removal, and `ring_buffer_is_empty`, `ring_buffer_is_full`, and `ring_buffer_num_items` to check the buffer's status and content count. The buffer size must be a power-of-two, allowing it to contain at most `buf_size-1` bytes, ensuring optimal performance for real-time data processing in embedded applications.

Rofunc is an open-source Python package designed for robot learning from demonstration and robot manipulation. It provides a comprehensive framework for developing and deploying advanced robot learning algorithms. The tool is hosted on GitHub, making it accessible for researchers and developers in the robotics field. Rofunc facilitates the entire workflow, from initial algorithm development to practical deployment, supporting various aspects of robot control and interaction. Its open-source nature encourages community contributions and collaborative development, making it a valuable resource for advancing robotics research and applications.

statik is a specialized tool designed for Go developers, facilitating the embedding of static files directly into a Go binary. This capability is particularly useful for applications that include web components, as it allows for the distribution of a single, self-contained executable. By integrating static assets like HTML, CSS, JavaScript, and images into the binary, developers can simplify deployment and ensure all necessary files are present. The embedded files can then be served efficiently via an http.FileSystem, streamlining the development and distribution workflow for Go-based projects with web interfaces. This approach eliminates the need for separate asset management during deployment.

sqlite3-ruby offers Ruby bindings for the SQLite3 embedded database, enabling Ruby developers to seamlessly integrate and utilize the SQLite3 database engine within their applications. This library is designed for compatibility with SQLite 3.6.16 or newer, ensuring a broad range of support for existing and new projects. It facilitates database operations directly from Ruby code, making it a valuable tool for managing data in Ruby-based applications. The integration simplifies database interactions, allowing developers to focus on application logic rather than complex database setup.

Stereo-RCNN is an open-source implementation for accurate 3D object detection and estimation, primarily developed for autonomous driving applications. This tool leverages stereo images to perform simultaneous object detection and association, enhancing the precision of 3D box estimations. It also incorporates a dense alignment module for refining 3D box predictions. The project supports Pytorch 1.0.0 and Python 3.6, with a light-weight version available for scenarios with limited GPU memory. Researchers and developers can utilize Stereo-RCNN for tasks requiring robust 3D perception from image-only data, offering a valuable resource for advancing autonomous systems.

Turbo is a robust framework designed for LuaJIT 2, aimed at simplifying the development of fast and scalable network applications. It leverages an event-driven, non-blocking, and no-thread design to achieve excellent performance and a minimal footprint, making it suitable for high-load applications and embedded systems. The framework supports various network applications, including HTTP REST APIs, dynamic web pages via templating, and WebSockets. It provides generic building blocks like an I/O loop and IO Stream classes, along with customizable TCP (with SSL) server classes. Turbo is particularly optimized for the HTTP(S) protocol, catering to web and HTTP API developers, while also offering direct integration with existing C libraries for ultimate memory and CPU performance.

vedadet is a single-stage object detection toolbox built on PyTorch, offering a modular design that re-engineers MMDetection for enhanced flexibility and deployment. It decomposes the detector into four key parts: data pipeline, model, postprocessing, and criterion, making it straightforward to convert PyTorch models into TensorRT engines. This design facilitates efficient deployment on NVIDIA devices such as Tesla V100, Jetson Nano, and Jetson AGX Xavier. The toolbox supports several popular single-stage detectors, including RetinaNet and FCOS, right out of the box. Its friendly integration with TensorRT allows for easy model conversion and deployment through both Python and C++ front-ends, making it a powerful tool for developers working on object detection tasks.