Explore Projects

My work involves porting the game SNKRX from Lua to Atmos, a versatile programming language that is based on concurrency, event-driven programming. The project focuses on replacing imperative Lua patterns—such as manual flag management and nested callbacks—with the main functionalities of Atmos to simplify complex game logic. Specific tasks include refactoring the screen management system into a hierarchy of scoped tasks, converting global variables into linear sequences, and modularizing character ability chains. Throughout the process, the project will measure how these reactive and parallel features improve code maintenance compared to the original implementation.

The end goal of this GSoC project is to design a simple and portable process for building and installing Pallene on any of the three major operating systems (Windows, macOS, and Linux). The process will not depend on any external services or system-level packages. No dependencies other than Make and a C compiler for building and installing Pallene. Deliverables: - Simplified build process. - Simplified install process. - Eliminating of dependencies on external systems for building and installing Pallene. - Updated documentation with the new steps. - Updated CI script with separate steps for building, testing, linting, and installing Pallene on all three major operating systems. - Reduced dependencies. - Removal of old build scripts.

The goal of this project is to create a documentation generator for the Teal programming language. The generator will extract information from types and comments to produce documentation in both Markdown and HTML formats. The tool itself will be written in Teal and will utilize its compiler as the primary source of information. By the end of this project, we will extend the Teal compiler to retrieve all the necessary information for documentation generation. Additionally, we will deliver a CLI tool capable of parsing Teal code files and generating documentation in various formats.

LuaRocks is the package manager for the Lua language. It is written in pure Lua, making use of several optional libraries. The goal of this project is to port the LuaRocks source code to Teal, a statically typed language that compiles to Lua (Teal is to Lua somewhat like TypeScript is to JavaScript). Porting LuaRocks to Teal comprises essentially of writing type annotations to its source code, but will also allow for many opportunities for refactoring and improving its codebase, understanding and reporting on limitations of the Teal language and possibly inform or contribute to its development.

<h5>Freechains Lua API.</h5> <p>This is an API for the Freechains project written in the Lua programming language. The lua-sockets library is used to interface with a daemon which string commands are sent to. This project manages the sockets for you and also provides optional extensions to work with the daemon abstractly without manually writing out strings of commands. This is to allow for concise creation of applications on-top of Freechains, and testing of the Freechains protocol.</p>

<p>Currently, the creation and management of Lua States in Lunatik bindings are made by the binding itself, which can difficult the interoperability of such systems, furthermore, leaving this task to the developer can increase the complexity of the binding. This project has the objective to move the states control to Lunatik, providing an API for these tasks in order to aid the binding development.</p>

<p>Project proposed by LabLua</p>

<p>The project consists of developing new interrupt-based drivers for microcontrollers, e.g.: ADC SPI and I2C buses EEPROM Real-time clock Some libraries built on top of these drivers (e.g., RF transceiver, ultrasonic sensor, accelerometer).</p>

<p>The idea of this project is to use Haskell as another way of reasoning about the typing rules of Typed Lua. Project involves implementing parser and typechecker for Typed Lua Core - Typed Lua dialect which does not contain any syntactic sugar what simplifies reasoning about typing rules.</p>

<p>Enable users to attach a script or Lua function to a watchpoint and execute it when the program flow hits it in LLDB and improve the whole documentation for Lua scripting in LLDB.</p>

<p>Developing interrupt-based drivers and libraries for Arduino chips and peripherals for the Céu-Arduino language, in order to replace current functions and libraries which freeze the application while executing.</p> <p>This project will make an overall contribution not only to the development of the Céu language but to the Arduino and Embedded Systems community as well.</p>

<p>Every Project's code seems good if it is in proper style. LuaFormatter is a code formatter which helps to style a code in Lua scripts which will also help in easy integration with various code editors But currently, LuaFormatter doesn't check if the configuration values make sense before using it. For example, a clueless user could use a negative value in a field where the range expected is [0, ∞). This project is to implement a lazy configuration validator for the LuaFormatter.</p> <p>After the completion of this project, the validator will be able enough to detect this kind of error and report it to the user in a nice, helpful way.</p>

<p>In this project we focus on package manager for Lua modules, LuaRocks. Our main goal is to increase quality of test suite, because it's implemented as a big shell script that only does black-box testing. So we write new test suite with Lua unit testing framework busted.This will allow us to extend the test suite by writing smarter tests that check its behavior, write white-box tests of the internals, and also port the test suite to other platforms. Next step is to improve code coverage, by adding white-box tests for parts that are hard-to reach via black-box testing. Make tests cross-platform could be a challenge for Windows operating system. At the end we integrated code coverage results, merging the Linux and Windows runs.</p>

<p>An application from Jingrui for Céu-Arduino, I'll do my best for that.</p>

The goal of this project is to make a new tool that connects Netfilter with Lua, allowing people to create new Netfilter programs using Lua and allows attaching callbacks to the netfilter hooks.

<p>The admin center would be pivotal in utilizing the autogen functions and a configuration file editor would make it easy for the end user to edit conf files. Elasticsearch integration would enable a user to store his database models in the search index for fast and efficient searches. Luagoogle can be used to get Google results programatically in lua at the backend itself.</p>

<p>This project involves improving the existing ARVR Server by adding support for the premium Mobile VR platforms. The goal is to improve the existing GDNatives for GearVR and implement support for the Daydream devices. This can be done by improving the newly implemented VR backend of Godot. The "Native mobile" interface can be modified to support both GearVR and Daydream. Alternatively, the existing Oculus interface can also be modified to support GearVR and a new interface can be designed to introduce Daydream support.</p>

Optimizing code for heterogeneous hardware like GPUs requires specialized approaches. While LLVM/Clang supports various GPU programming interfaces, LLVM IR hinders effective analysis for GPU code with its SIMT model. Clang's mid-level IR (ClangIR) based on MLIR is better suited to capture this information from source code. This project proposes adding basic OpenCL C support to ClangIR. Challenges and Solutions: 1. Code Generation Paradigm Shift: CodeGen and Lowering (ClangIR's compilation passes) employ distinct coding paradigms due to their underlying infrastructure (AST reflection vs. MLIR Pass Rewriter). Migrating existing CodeGen code to the Lowering framework could be complex. We will actively debate the trade-off between optimization potential and implementation complexity to propose and execute well-designed, achievable plans. 2. Scattered OpenCL Support Code: Current OpenCL support code is dispersed throughout the codebase, hindering development quality control. Strategies will be developed to address this issue, such as extracting key information from flags like getLangOpts().OpenCL and getOpenCLRuntime(), or implementing systematic code searches to consolidate functionalities and address issues in a structured manner. The final deliverables of this project include a) A set of testcases that combines unit tests with integration tests b) An AST Consumer for OpenCL C (extension of CIRGen) c) A set of MLIR Passes for properly generating SPIR Kernels d) A functional and performance test report (optional) e) Detailed development documentation for all the above parts

<p>Panda3D is a mature 3D rendering engine both in age and functionality, addressing the need for the rapid prototyping of games while still providing stability for large projects. As a result of this maturity, however, Panda has been slow to take advantage of newer platforms and devices, with no support for iOS and only experimental support for Android. Adding support for iOS will make the engine much more appealing to new developers, while also creating the opportunity to update more antiquated areas of the engine. Many of these features will aid in future work on Android support as well.</p> <p>Goals for this project include:</p> <ul> <li>iOS build support using CMake</li> <li>A flexible system that allows Panda to either run in a dedicated app or run alongside other UIKit elements</li> <li>Improved multi-touch support</li> <li>Documentation and unit testing</li> </ul>

<p>Rust is a rather new programming language, but it has already gained a lot of traction. It was voted “most loved” language by developers for the second year in a row in the StackOverflow developer survey. There have been projects made using Rust on everything from operating systems to game engines for Minecraft-like games. Despite this, IDE support is still lacking. KDevelop currently does not support Rust at all. The end goal of this project would be to add support for all the standard features an IDE should support for a language.</p>

<p>This project when completed gives ardupilot the ability to control a walking robot. To be able to do that ardupilot needs new modules which support the kinematics model required by the robot . The walking robot will also have support for existing modes and new vehicle specific modes.</p> <ol> <li>Implementation of walking robot over ardupilot </li> <li>Solid kinematics model </li> <li>Simulation support </li> <li>GCS support </li> <li>Documentation</li> </ol>

KomaMRI.jl is a Julia package for Magnetic Resonance Imaging (MRI) simulation focused on speed and extensibility. Like other MRI simulators, it solves the Bloch equations, for which the solution can be parallelized due to the independent spin property of the system. Although KomaMRI currently has built-in support for GPU and CPU parallelization, GPU support is CUDA-based and could be extended to work with different GPU backends. In addition, writing GPU kernels tailored for the solution implementation could significantly improve performance compared with the current array-based approach. The goals for this project are to update the KomaMRI.jl package to support Metal, AMD, and OneAPI-based GPU backends, and create a new BlochKernel simulation method which is fully kernel-based and optimized. If time permits, the use of MPI.jl and Distributed.jl to run MRI simulations across multiple nodes and GPUs will also be explored.

<p>This project proposes to add the support for APE14 in NDCube, which is a SunPy-affiliated project. In order to support both FITS-WCS and gWCS and hence support more future WCSs libraries, this project aims to convert the ndcube package to use a common WCS API. The new API has already been outlined by astropy’s APE14. Implementing support for APE14 will enable ndcube to use FITS-WCS and gWCS independently and hence increase the power and scope of the ndcube package. With this new feature, NDCube will become better placed to serve a wider array of n-dimensional data analysis needs from multiple astronomical communities.</p>