Explore Projects

<p>I will consider and conduct a survey about the data structures appropriate to the operations used in Ruby, and combine their merits by dynamically selecting the moderate implementation from types of data structures.</p> <p>Ruby is beloved by its simplicity and productivity. It is common to implement optimized data structures when working in C, but it should not impose users of the high level languages like Ruby to the task of implementing optimized data structures by themselves. However, it is necessary to select appropriate data structures in order to achieve efficient access to the data structures.</p> <p>It seems possible to offer some implementations per data structure in Ruby, and select it implicitly in order to offer desirable performance without difficulty to the users.</p> <p>For example, List is a basic structure for programmers, but Ruby does not offer it. Instead, Ruby programmers use Array. In fact, Array offers List like methods such as insert, delete, push back and more. Hence, it is easy to use, but the performance of these methods like insert and delete are not executed at a constant time, while they in List run at a constant time. (Similar ideas would be possible on String and Hash.)</p>

<h3>GSoC 2021 Proposal: Tests for debugger</h3> <h4>Overview</h4> <p>debug.rb is a replacement of the traditional lib/debug.rb standard library which is implemented by set_trace_func. New debug.rb has several advantages. However, it is hard to write test codes for them.</p> <h4>Proposal</h4> <p>This is a proposal to implement tests for a debugger based on deivid-rodriguez/byebug: Debugging in Ruby 2. Test codes for byebug consist of two parts. The first part is the test framework for test byebug. It extends minitest. The second part is tests for byebug using the test framework. It doesn’t test each method, but situations such as the existence of a breakline. I will implement test codes for debugger referring to them.</p>

<p><strong>Upgrade the Rails to 6.0.0 and patch all 169 Debian packages that depend on the Rails to be compatible with Rails 6.0.0.</strong></p> <p>Rails <em>(Ruby on Rails)</em> is one of the most popular web frameworks in the world. Rails is distributed in several distributions, and Debian is one of them.</p> <p>Almost of web applications made with the Rails are distributed using RubyGems. RubyGems is a package manager in Ruby, and is designed to distribute the web libraries multiple versions at the same time. This can make the Rails applications maintain with multiple version of the Rails frameworks. However, the package management system in Debian is designed to deliver one version at a time, which cause mangling the dependency relationship.</p> <p>Currently, the Rails version in Debian is 5.2.2. All of the Ruby applications and libraries in Debian are dependent on the Rails 5.2.2. This proposal proposes to upgrade the Rails to 6.0.0 and patch all 169 Debian packages that depend on the Rails to be compatible with Rails 6.0.0.</p> <p><a href="https://jongmin.dev/go/gsoc-2019" target="_blank">The full proposal and the final report are available here.</a></p>

<p>This project would add a feature on the rubygems.org website to give an option on each gem web page to show a tree/DAG of all transitive dependencies needed by that gem. In one of the issues that lead to this project, a user talks about how some users download a gem based of it’s transitive dependencies and how they need to keep a mindmap of these transitive dependencies to conclude whether or not to use the gem. This project will help such users get a better idea of whether that gem is for them or not.</p>

Documentation refers to the additional text associated with a codebase to help developers and/or clients/users understand the code/use cases better. Documentation is of two types - 1) Documentation within the code and 2) Documentation about the code. Ruby supports the generation of documentation for a particular codebase using comments written internally in files by tools such as RDoc, and YARD. RBS is a newly developed language for describing the structure of Ruby programs. RBS, similar to Ruby, supports adding comments in the source file. Hence, this feature can be effectively utilized to write encoded inline documentation to later generate well-formatted markup documentation. RBS currently has support for a lot of features. RBS can find its arguably best application in generating typed documentation of a particular codebase.

<p>Gem-web is a tool that capable of providing an interface that allows opening documentation, source code and website of a ruby gem. Integrating it on RubyGems CLI would make this feature available out of the box to all ruby users, improving their productivity, since there would have no need to search this information manually.</p>

<p>This is to develop a plugin system for bundler which can be used to add features like CLI commands, new sources for ruby gems and hooks for lifecycle events without modifying the core bundler project. This can enable the community to customise bundler without messing with the core module and also can be used as staging area for future bundler features.</p>

<p>Dynamic languages trade some of the compile-time safety properties of statically typed languages for greater flexibility for a programmer to write correct programs that a static compiler would turn down as potentially faulty. There is a recent trend to integrate aspects of both disciplines, commonly by "adding types" to languages originally designed as dynamic.</p> <p>There has been interest in the Ruby community to explore such an approach: Yukihiro Matsumoto devoted his keynote at RubyConf 2014 to the potential implementation of static typing in the language. The topic is complex: a Ruby tightly corseted by types would not be true to the essence of the language.</p> <p>Under a gradual typing discipline, type annotations can be specified at will: interesting parts of the program can be given explicit types and their type safety checked statically. We propose an implementation of gradual typing in Matz's Ruby Interpreter, drawing inspiration from similar additions to other dynamic languages, with strictly optional type annotations consistent with Ruby's DRY and "lazy" philosophy and an evaluation of the practical usefulness of gradual typing.</p>

Scarpe is a project designed to resurrect the shoes library using modern technology. This project aims to leverage an HTML/CSS/JS/RUBY stack to develop GUI apps, which can be deployed across various platforms.. The primary objective of Scarpe is to bring it closer to shoes by ensuring that all known examples run seamlessly. The project also aims to create comprehensive documentation and build an official Scarpe website to provide easy access to project resources. Furthermore, there are plans to make Glimmer lib UI an efficient secondary display service. Scarpe represents a significant opportunity to modernize the shoes library and bring it to a wider audience

<p>In RubyGems.org website, we can search for any kinds of gems you want. However, most programmers use google or any other websites to look for gems which they want to use. So, who is using RubyGems.org? The answer is a beginner and intermediate for Ruby, who are not familiar with CUI but familiar with GUI. Therefore, I propose to add autocomplete and some functions which help GUI familiar people.</p>

<p>Currently, several problems are known when Ruby program runs under a high memory workload, including slow rates for allocating memory and program termination. We need to find out the reasons for unexpected overhead of memory operations of Ruby GenGC algorithm. The addressed problems like termination and collection data type may have relevant or irrelevant reasons behind it. Technically, the high effective and efficient garbage collection management in JRuby and Rubinius thanks to the underlying virtual machine and more modern GC algorithms. These GC algorithms are also used partly for reference in Ruby GenGC. To solve the high latency problem during manipulating a big hash table with millions of key-value pairs, we aim to design a GenGC friendly data structure. We are also planning to address other issues like the multithreading conflict found in my experimental program when 8 threads ran under a high memory workload.</p>

Ruby 3 introduced Ractors, which allow true concurrency in the language. However, Ruby's stop-the-world Garbage Collector (GC) pauses all of the Ractors when doing Garbage Collection. This diminishes the efficiency of using Ractors. This project proposes to modify the Ruby GC to improve its performance with Ractors, ideally by having only one Ractor paused at a time. The idea is to investigate the ways in which the GC can avoid interfering with objects belonging to Ractors that it is not working on, which would allow these Ractors to continue unhindered during Garbage Collection. The final objective would be to have code for an improved version of Ruby's GC with measurable gains in efficiency.

<p>I would like to add type annotations to Ruby, per the ideas list. These annotations will serve as documentation and hopefully a way to implement basic typechecking for third party tools. Following the guidelines posted in the Ideas page, the project will consist of 3 parts: adding the type information to the parser generator, modifying Ripper to emit the type annotation information with the parse tree, and writing a detailed proposal to add this feature to a future version of MRI.</p>

<h3>Cap'n Proto RPC implementation </h3> <h4> Project idea</h4> <p>There is already a decent binding of Cap'n Proto in github but it doesn't have RPC. My project consist in extending the existing code by adding a level one RPC implementation by wrapping the existing C++ official classes in ruby.</p> <h4>My proposal includes: </h4> <ul> <li>Risk management.</li> <li>Definition of optimal and sub-optimal solutions.</li> <li>Planning , milestones, and deliverables.</li> <li>The another items requested in "How to work with us".</li> </ul>

This project aims to improve feature parity between TruffleRuby and CRuby in places where full Ruby 3.0 feature parity has not been achieved, aiming at Ruby 3.0 pattern matching specifically.

Building modern Text User Interfaces (TUIs) often forces developers to choose between writing complex, low-level terminal sequence code or adopting restrictive, framework-specific solutions. This project addresses this fragmentation by bringing the universally beloved, declarative Shoes GUI DSL (via the Scarpe project) to the terminal environment, allowing developers to build complex CLI applications intuitively. The proposed solution leverages a robust, dual-language architecture. The frontend consists of a pure-Ruby DSL where developers define UI layouts and business logic. The backend is a custom-built, high-performance Rust rendering engine responsible for flexbox-like layout calculations, double-buffered differential rendering, and non-blocking event polling. These two layers communicate seamlessly in real-time through a memory-safe C-FFI (Foreign Function Interface) bridge, ensuring the Ruby VM is never blocked by terminal I/O. By the end of the project, the clearly defined deliverables are: 1) A Universal Low-Level TUI C-API: A standalone Rust rendering engine exposing a clean C-ABI, making it usable not just by Ruby, but by any FFI-capable programming language. 2) The scarpe-tui Ruby Backend: A complete mapping of core Shoes elements (stack, flow, button, edit_line, styling, and clipping) to the terminal grid. 3) An Advanced Showcase Demo: A complex, asynchronous CLI application (inspired by "Claude Code") featuring scrollable histories and bidirectional data flow, proving the framework's readiness for real-world production use. 4) Comprehensive Documentation and Test Suites: Ensuring maintainability and easy community adoption.

<p>Gemstash has long been serving as a private gem source for developers who wanted to inhabit a personal environment to update and develop their gems. However, it seems unlikely that a gem production is the work of an individual, and therefore gemstash needs to improve its capabilities for team-based projects across different machines. I seek to implement a cloud-storage system to Gemstash that will allow gems to be shared, and used across internal machines effectively.</p>

<p>Allows Rubyists to enforce a type into a parameter without any DSLs</p>

The project this document proposes is that of implementing the hash map structure described in high level detail in the article Hash Maps That Don’t Hate You (https://blog.toit.io/hash-maps-that-dont-hate-you-1a96150b492a), an elegant variation over standard open addressing hash tables that, instead of storing the Key-Value pairs themselves in the array backing the hash table, it stores indices into yet another insertion-ordered backing array. This allows us to have our cake and eat it too : we get insertion-order iteration while still maintaining most of the desirable performance guarantees expected from hash tables, with reasonable implementation complexity. Deliverables: A build of truffleruby with a Hash implementation as described in the article, supporting all standard Ruby Hashes operations (as of Ruby 3.1) and hopefully faster and\or more memory efficient than the current implementation of Hashes in truffleruby.

<p>Ruby has no native ByteArray or ByteBuffer types, unlike Java. While it'd be great to have something like this in core Ruby, the next best place would be in the New IO for Ruby project, which provides a thin wrapper around Java NIO. The goal of this project would be to wrap Java ByteBuffers (particularly direct ByteBuffers) in a Ruby class that can also be implemented in pure Ruby which hooks into nio4r and can be used directly with nio4r's Java NIO backend.</p>

<p><strong><em><a href="https://github.com/rails/web-console" target="_blank">Web Console</a></em></strong> is a debugging tool for the web apps built with Ruby on Rails. In order to debug, it provides an interactive Ruby session to the developers. The console is displayed in the current page of the browser, and its session stores context of running code of the web app. It allows us to debug the web apps interactively.</p> <p>This project aims to make a better user experience for Web Console as a whole, and the main focus is to support <strong><em>"auto-completion"</em></strong> feature, which is to help us typing commands speedy and quickly on the console.</p> <p>And also, this project is getting into ways to extend Web Console. The other goal of the project is to create <strong><em>"built-in commands"</em></strong> and its architecture, which makes Web Console more extendable, and it can open the door to yet another contributors.</p> <p>A point worthy of special mention is that the above features are working on the inner of console, and it basically does not need new things for the HTML view of Web Console.</p> <p>Details: <a href="https://github.com/sh19910711/google-summer-of-code-2016" target="_blank">https://github.com/sh19910711/google-summer-of-code-2016</a></p>

LowType currently relies on shim methods to bypass type checking when disabled, adding persistent runtime overhead on every method call through define_method closures and repeated Lowkey proxy lookups. This project eliminates that overhead entirely by rewriting typed methods directly onto the class using class_eval, producing plain untyped Ruby methods indistinguishable from hand-written code. Deliverables include removal of the shim execution path, class_eval based method rewriting integrated with Lowkey export methods, edge case handling for kwargs and defaults, benchmark results using benchmark-ips, and full test and documentation coverage. A working prototype already exists with real benchmark results showing 1.8 to 2x improvement over the current shim.

<h3>Writing of RBS Files</h3> <ul> <li>Ruby is an extremely easy to use, syntactically elegant, dynamically typed language. </li> <li>Ruby announced the release of RBS, a syntax language to describe the structure of Ruby programs, with the release of version 3.0</li> <li>RBS is an extremely useful tool chain that can be used to run static type checks on your Ruby programs to prevent type mismatch errors to the maximum extent.</li> <li>This project mainly aims at providing RBS files for third party gems, integrating it with the RBS CLI so that Ruby developers can utilize these files to run type checks on their programs. </li> <li>This project also aims at fixing/improving the functionality of the current RBS tool chain, since RBS tool chain is a recent initiative undertaken by the Ruby Core Team.</li> </ul>