It supports Suspense-based Streaming SSR with React 18 and Relay,
and is configured to support Render-as-you-fetch by specifying GraphQL queries per page.

While looking for a suitable SSR framework to use in production at my company,
I couldn’t find an optimal framework for use with Relay, so I decided to create one myself.
It is currently being used in the development of new products at my company.

It works well in edge runtime environments such as Cloudflare Workers,
and advanced SSR techniques like Selective Hydration are planned to be applied in the future.

Although I previously received inquiries and open source contributions related to collaboration and usage from various channels,
the framework has now been archived as we are no longer working on projects that use it.

Written entirely in ReScript except for the service worker, implemented a resource management system using Cloudflare Workers infrastructure,
and applied caching for offline use with a Workbox-based service worker.

Currently, only a very incomplete Relay-compatible GraphQL API server exists,
with implemented features such as account and JWT-based authentication systems and direct messaging (DM).

By writing various macros using Rust’s Procedural Macro system,
issues like implementing Global Object Identification with minimal code were resolved.

Future plans include implementing a game system using Server-Driven UI and GraphQL Subscription.

All code was written in ReScript, implementing a voting system using Firebase Functions and Firestore,
and applying real-time data updates using Firestore.
Additionally, issues such as implementing smooth transitions between gradients were resolved.

This was a graduation project conducted at Full Sail University.

Implemented dynamic rendering of subtitle images using Vue.js and html2canvas.
Resolved type safety issues in the template component system, Pinia Store, and Electron IPC system
by leveraging TypeScript’s type utilities.

This project was conducted as part of a portfolio class at Full Sail University.
It operates by using the teVirtualMIDI driver, which creates a virtual MIDI device,
and converts the XY coordinates and pressure values received from the pen tablet into MIDI signals,
allowing the pen tablet to be used like an instrument when connected to a DAW.

I attempted to directly read tablet information through WinTab API integration,
but failed due to a lack of knowledge regarding C/C++ API integration, which remains the most regrettable part of this project.

Created while learning Dart, Flutter, and Android development, this project was instrumental in learning how to compose UIs using various widgets.

Implemented matching API using Firebase Functions, integrated Google Maps to display the current location of each carpool member,
and integrated Stripe for carpool fare payments.

The app was not put into actual operation due to legal issues related to Stripe integration (foreign nationals).

I created a type-safe binding using TypeScript,
set up the build system using CMake.js, including adding the TagLib dependency,
and successfully published it on NPM.

Although I planned to add many features such as a Promise-based API, the project is currently on hold due to a lack of personal interest.

When the League of Legends board was newly established on Ruliweb, the various utilities (item DB, strategy system, etc.)
used in the existing community (LoL Inven) were very lacking, and this project was developed to address that issue.

I integrated Riot Games’ League of Legends API and implemented a system for uploading strategies using Firebase.

SolidJS’s JSX transform converts JSX into DOM element creation and state change subscriptions.
Since this transform only supported Babel, a community effort was started to port it to swc,
but the progress had been slow.

First, I added a significant amount of logic for handling the use of components within JSX,
improving the plugin to support not only general DOM elements but also components within JSX. (#1)

Later, I implemented additional features such as optimizations for handling constant values
and support for framework built-in components (e.g., For, Show), enhancing the completeness of the plugin.

The updates for this project had stopped since 2020, and it did not support the latest specs such as @defer and @stream.
To facilitate related testing, I updated the entire project.

I replaced the previously used Apollo Server with GraphQL Yoga 2.0,
and modified the mocking data layer to support Promises,
configuring resolvers to support @defer and @stream. (#15)

Subsequently, at the maintainer’s request, I developed the envelop-plugin-relay-defer
to support the unofficial @defer/stream style used by Relay, and completed a PR to apply the plugin. (#16)

UnoCSS provides various features through multiple presets.
Among them, the Attributify preset allows you to specify Atomic CSS classes as if they were regular properties,
and it further offers a feature called Valueless Attributify, which applies styles when the attribute name is written directly on the tag.

However, an issue was reported that this feature does not work in SolidJS (#878).
To resolve this issue, I added an option that makes slight modifications to the CSS generated by UnoCSS to ensure compatibility with SolidJS. (#899)

Yarn PnP replaces the traditional module system that uses the node_modules directory.
ReScript’s dependency system, however, only works with a node_modules-based module system,
so generally, Yarn PnP cannot be used with ReScript.

The role of this plugin is to circumvent this issue by using a node_modules-based module system
only for dependencies referenced by ReScript.

I improved the plugin to resolve issues where dependencies of workspace members could not be fetched
and where one member depended on another member in a Monorepo environment. (#5)

async-graphql generally works with other backend frameworks,
providing integration packages for popular backend frameworks.
Among these, the integration package for the Rocket framework did not support the latest RC Release,
so I added support for it. (#545)

juniper generally works with other backend frameworks,
providing integration packages for popular backend frameworks.
Among these, the integration package for the Rocket framework
did not support the version of the latest master branch that includes async support,
so I added support for it. (#905)

vee-validate wraps input elements to be validated with the ValidationProvider component,
automatically detecting elements with the v-model attribute to validate field values.

While it also provides a way to manually call the validate function for cases where v-model is not used or in other scenarios,
there was an issue where elements with the v-model attribute were always designated as the target elements for validation.

I improved this behavior by adding the detectInput attribute to enable or disable this feature,
and added test code using Jest. (#2980)