Projects

• Qob or cl-qob/cli (Fall 2024 – Present 🏅🏅🏅🏅): CLI for building, running, testing, and managing your Common Lisp dependencies.
• cogru (Summer 2024 – Present): Where the collaboration start!? I’ve implemented the Operational Transformation (OT) in Rust using the client-server model.
• jayces (Winter 2023 – Present): Programming language I’ve created to learn the to write one my own.

• JCSNetP (Winter 2017): A framework is developed to improve efficiency in network programming using C++.
• JCSQtJ (Fall 2017): A compact framework that encapsulates Qt Jami to expedite development. Explore additional projects that have utilized this framework, such as Guild-Emblem-Simulator, OC_Install, and more.
• JCSNetS (Summer 2017): A dedicated network framework tailored for the creation of MMO games, leveraging Apache Mina and MySQL. Please checkout the project BB_Shoot, which utilizes this framework.
• JCSPyGm_Lib (Winter 2016 🏫): A set of tools designed to boost the speed of game development with Pygame. Please visit the demo project ImpulseEngine for more detailed usage information. (6 weeks; including the demo project)
• JCSCos2x_Lib (Fall 2016 – Winter 2016 🏫): A small library provides a fast, superficial, easy-to-implement layer for parallax effects and essential features for making a 2D game using Cocos2d-x. Watch a short video of the demo project here. (4 weeks; including the demo project)
• JCSLOVELua (Fall 2016 – Winter 2016 🏫): A game framework built on the LÖVE 2D engine that enhances productivity and user experience by providing commonly used systems pre-implemented (animation, camera, input, rendering, simple physics, etc). Please checkout the demo project PetShop for more detailed usage information. (5 weeks; including the demo project)
• JCSCC_Engine (Spring 2016 – Winter 2017 🏫): A game engine offering a straightforward programming interface for developing cross-platform native code games. It includes a resource manager with secure decoding and encoding algorithms. The project’s goal is to gain insights into the construction of game engines, understand their architecture, and apply this knowledge to other modern game engines.
• JCSStarling (Spring 2015): This is a programming interface layered on top of the Starling framework, transforming the event-driven system into a component-driven system.

• Unity.Prefs (Fall 2023): A small library designed to fetch a list of EditorPrefs/PlayerPrefs.
• Unity.Mx (Fall 2023): A command-based completion framework. It allows you to execute all kinds of tasks based on your design. The idea is to port the M-x functionality from Emacs.
• NovBundle (Fall 2021 – Spring 2022 💸🏅): An abstraction layer constructed atop the AssetBundles system, aiming to streamline the AssetBundles workflow, sparing users from delving into intricate system details.
• WatchLog (Summer 2021 – Fall 2021 💸🏅): A dedicated tool that tracks variable over time.
• Inspect Yaml (Summer 2021 💸🏅): A dedicated and up to date YAML editor inside the Inspector window.
• Inspect Xml (Summer 2021 💸🏅): A dedicated and up to date XML editor inside the Inspector window.
• Inspect Json (Summer 2021 💸🏅): A dedicated and up to date JSON editor inside the Inspector window.
• Afterimage (Summer 2021 💸🏅): Afterimage VFX for Unity. A simple solution that work with 2D and 3D renderers, including UI components (Image, Text, Button, etc).
• sHierarchy (Summer 2021 💸🏅): Minimalistic good looking hierarchy.
• UnityWzLib (Summer 2021): WzLib for Unity.
• 32feet.Unity.Example (Spring 2021): Example project to use 32feet inside Unity (Bluetooth Classic).
• UnityLua (Spring 2020 💸): Use Lua scripting language (tolua) in Unity to accomplish hot update/fix functionality.
• Unity_UndoRedoSystem (Summer 2018): Implementation of an Undo-Redo system in Unity using C# and uGUI.
• Unity_Toggle (Summer 2018): A little bit overkill toggle button UI for Unity Engine using uGUI.
• PackageExporter (Winter 2017): An alternative approach to package management utilizing ignore files.
• JCSUnity (Summer 2016 – Winter 2017): Quickly construct your game using multiple components and predefined default settings.

• You Have An Order (Summer 2024): A 2D pixel horror game, players strive to evade monsters while searching for an escape route. This game participates in the 机核GCORES 2024 Game Creation Challenge. (3 weeks)
• Alice in Surprise (Summer 2022): A mini-game that combines the mechanics of hack and slash with tile-matching. The game has been submitted to the 5th DIY Game Jam. (4 weeks)
• Pipeline Of Emperor Yu (Fall 2019 – Winter 2019 💸🏅🏅🏅): A puzzle game that merges historical legends with the classic gameplay of water pipe challenges!
• Greedy Island (Fall 2018 – Summer 2019 💸): A multiplayer shooting MOBA game on the mobile device. The project is created by the T-NEXUS studio. I contributed to the backend engineering by writing the login server and designing its database schema.
• Sugar Sleuths (Fall 2017 – Winter 2017 🏫🏅🏅): A mulitplayer, hot-seat game in which the campers (players) discover clues that point to the Master Candy Thief.
• BB_Shoot (Fall 2017): A bullet bounce game featuring multiplayer third-person shooter (TPS) mechanics.
• Hemlock and the Horrible Net (Spring 2017 – Summer 2017 🏫🏅💸): Embark on an undersea adventure in this side-scrolling game! (15 weeks)
• PetShop (Winter 2016 🏫): An example project using JCSLOVELua Framework. Players can use a left-click of the mouse to generate adorable animals, allowing them to reside within a sandbox. The concept is to emulate an aquarium experience.
• Might & Blade (Fall 2016 – Winter 2016 🏫🏅): A 3rd person hack and slash action game made in the Unity engine, developed by a team of 18 in the Academy of Art University within a span of 15 weeks.
• DJMax_Remake (Spring 2016 🏫): A clone of DJMax implemented in Processing.
• TPS (Fall 2015 – Winter 2015 🏫): A simple ASCII third-person shooter (TPS) game coded in C++. View the gameplay video here.
• Project S (Summer 2015 – Winter 2015 💸): Action game (ACT) with RPG elements and a locked top-down perspective. I worked on the minimum viable product (MVP) of a game under NDA as the sole software engineer. The game wasn’t completed due to its 7+ years project timeline, so I passed it on to the next team.
• Archers Duel (Winter 2014 🏫🏅🏅): An compact RPG fighting game designed for two players to engage in battles using pre-designed archer characters. Developed with the Starling framework. and AS3. (7 weeks)
• Cardinal (Fall 2014 🏫🏅): A compact visual novel game where the player assumes the role of a detective, working to unravel a mystery and identify the murderer. (7 weeks)
• Rhythm Punks! (Fall 2014 – Winter 2014 🏫): A competitive two player game that will have the player fighting one another for victory. The first stage will be a death match between the two players, the second stage will have the players fighting enemies to see who can kill the most while dying the least. The 3rd stage will be a boss fight, where the player who does the most damage wins. (14 weeks)

• OC_Install (Summer 2018): An univseral software installer by one click.
• MagicCardTool (Summer 2017 🏫): A small desktop application that generates an image of a card for the Magic: The Gathering card game. Initial attempt to develop a desktop application with Windows Forms using Visual C#.
• Guild-Emblem-Simulator (Fall 2017): A small program that allows you to customize your guild emblem just like in the game MapleStory and export it into a PNG file.
• Skycrap Client/Server (Spring 2017 – Summer 2017): A small and enjoyable project that transmits webcam data using the server/client model. Implemented in Java, this project utilizes the Apache Mina framework.

• Monumental Conversations (Summer 2021 – Spring 2022 💸🏅🏅): An augmented reality mobile app for learning history of Monument Avenue and Arthur Ashe Boulevard. This project was featured in CODAworx’s magazine’s Art for Social Change edition.
• Lights & Delights (Winter 2020 – Spring 2021 💸🏅): An augmented reality holiday adventure for the Downtown Seattle Association’s 2020, Holiday Lights and Delights Festival.
• Twilight Tower LiveVR (Spring 2015 🏫🏅): A mini marker-based AR game, utilizing the Vuforia AR SDK within the Unity platform. Players can interact with objects in the scene by simply clicking on them.

• Meteo (Spring 2020 – Spring 2021 💸🏅🏅🏅): An app for sharing music that works with illuminated piano keyboards — Meteo piano. You can view a demonstration of the core mechanics here (please note that this demo is in its early stages and may appear rough).
• Music_Visualizer (Fall 2018): Implementation of a music visualizer in Unity. Check out the demo here.

• 2D_Visibility (Summer 2024): Implementation of 2D Visibility in Unity using C#.
• AStar (Summer 2023): Implementation of A-star in Unity using C#.

Fuzzy Matching

• flx.py (Winter 2024 🏅): Rewrite emacs-flx in Python.
• flx_dart (Winter 2024 🏅): Rewrite emacs-flx in Dart.
• clj-flx (Winter 2024 🏅): Rewrite emacs-flx in Clojure.
• flx-java (Winter 2024 🏅): Rewrite emacs-flx in Java.
• cl-flx (Fall 2024 🏅🏅): Rewrite emacs-flx in Common Lisp.
• flx-zig (Spring 2024): Rewrite emacs-flx in Zig.
• zig-flx (Spring 2024): Zig bindings for flx-c.
• flx-c (Spring 2024): Rewrite emacs-flx in C.
• flx-ts (Spring 2024 🏅): Rewrite emacs-flx in TypeScript, with added support for JavaScript.
• FlxCs (Fall 2023 🏅): Rewrite emacs-flx in C#. Built on the Mono framework, you can utilize this in any environment compatible with Mono. This is utilized within the Unity.Mx tool.
• flx-rs (Winter 2021 🏅): Rewrite emacs-flx in Rust for dynamic modules. The original emacs-flx were written in pure Emacs Lisp. While their scoring engine is impressive, the performance is unbearable on Windows systems. Therefore, this package was developed, leading to a speed increase ranging from 10x to 16x.
• flxy-rs (Winter 2021 🏅): Fast, character-based search library in Rust. This represents my first attempt to rewrite emacs-flx in Rust, which was not successful. Although it remains usable, the results in terms of fuzzy matching were not as impressive as the original emacs-flx algorithm.

• Grass_Sway (Summer 2023): Create a grass sway effect in Unity using Shader Graph with Universal Render Pipeline (URP).
• Better_Skybox (Summer 2023): Enhance the overall visual experience by adjusting various settings in Unity.

• ImpulseEngine (Fall 2017 🏫): An unofficial port of Impulse Engine written in Python. This is constructed using JCSPyGm_Lib layered on top of Pygame.

• JCS-EMACS Homepage (Spring 2022): Landing page for jcs-emacs. This webiste is made using React.js.
• JCS-ELPA Homepage (Winter 2021): A homepage for JCS-ELPA designed to showcase all packages in the archive. The site only consists of basic HTML, CSS and JavaScript.
• Pixisoft Website (Summer 2021 – Winter 2021 💸): A small web application made using React.js, designed for use as a company’s homepage.
• sherlock-web (Spring 2021): Website to interact Sherlock API.
• sherlock-project/api (Spring 2021): API for the sherlock module implemented in Python using Django REST Framework (DRF). Initial attempt with DRF.
• box_server (Spring 2020 💸): A straightforward server designed to be compatible with any WebSocket client utilizing the ws library. This is a small demo I developed while working at WISBET. There is no documentation as we moved on to the next project afterward.
• Unity_DataServer (Winter 2019 💸): A data server and a solution for the missing game data, including in-app purchase (IAP) history, when the game is uninstalled from a mobile device.
• sherlock (Spring 2019 ✨): 🔎 Hunt down social media accounts by username across social networks. I was one of the early contributors who took care of the ANSI color using colorama.
• Links_Template (Spring 2020): Rapidly build your link page to marketing your games!
• RandomCookMenu (Winter 2017): A small application that enables you to create cooking menus and randomly selects one for you. This was originally designed for my mom, who often struggled with deciding what to cook every day.
• MapleStory Survival Kit (Summer 2017 🏫): A website that guides you on navigating the popular MMORPG, MapleStory! Constructed using only fundamental HTML, CSS, and JavaScript, this is the final project from our first web design class at the Academy of Art University.
• Best Boba Tea (Summer 2017 🏫): A website recommends a few boba tea places in San Francisco! Constructed using only fundamental HTML, CSS, and JavaScript, this is the midterm project from our first web design class at the Academy of Art University.

👤 Blog and personal websites

• jcs-profile (Spring 2024): My personal website version 2, using Hugo and PaperMod theme.
• blog@v2 (Fall 2022 – Spring 2024): My personal blog site, built using Hugo with LoveIt theme.
• blog@v1 (Fall 2021 – Fall 2022): My personal blog site, built using Hexo with hipaper theme.
• jcs-profile@v1 (Winter 2018 – Spring 2024): My single page personal website implemented in basic HTML, CSS and JavaScript
• Blog_JenChieh (Winter 2018 – Winter 2020): The blog system I initiated during my university years was constructed using the Blog_Template. I later shifted to a Static Site Generator (SSG) solution to minimize my server costs.
• Blog_Template (Winter 2018): A blog template that allows individuals to self-host their blogs! Constructed using Node.js and Express.js. (replaced with SiraDoc)

📚 Documentations and manuals

• Qob Manual (Fall 2024 — Winter 2024): Qob’s documentation website.
• collaboration-server-protocol (Summer 2024 — Fall 2024): Defines a common protocol for collaboration servers. Built with docsy.
• Scripting_Manual_JCSGodot (Winter 2023): Scripting manual website for JCSGodot API.
• Eask Manual (Summer 2022 – Winter 2022): Eask’s documentation website.
• CCosQuick Manual (Fall 2021): The documentation website for my game framework — CCosQuick.
• JCSEgret Manual (Fall 2021): The documentation website for my game framework — JCSEgret.
• JCSUE Manual (Fall 2021): The documentation website for my game framework — JCSUE.
• JCSUnity Manual (Fall 2021): The documentation website for my game framework — JCSUnity.
• SiraDoc/demo (Fall 2021): Demo website for SiraDoc.
• Scripting_Manual_JCSUE (Summer 2020): Scripting manual for JCSUE API.
• Scripting_Manual_CCosQuick (Spring 2020): Scripting manual for CCosQuick API.
• Scripting_Manual_JCSEgret (Winter 2018): Scripting manual website for JCSEgret API.
• API_Reference_Template (Winter 2018): Simple API references webiste hoster. (replaced with SiraDoc)
• Scripting_Manual_JCSUnity (Fall 2018): Scripting manual for JCSUnity API. Later separated into API_Reference_Template and subsequently reliant on it.

• password-toggle (Summer 2024): Show/Hide passwords on the page.
• eyny-video-downloader (Spring 2024): An extension that integrates a download button for EYNY Video site.
• browser-statistic (Spring 2024): This is a small extension that presents statistical charts indicating the websites you frequently visit.

• emacs-eask/packaging (Fall 2023 – Winter 2023): Packaging for Eask CLI. I’ve actively contributed to diverse package managers such as Chocolatey, Snapcraft, MacPorts, etc. Furthermore, I’ve established my own package repositories for Scoop, Homebrew, Personal Package Archive (PPA), and more.
• emacs-eask/archives (Spring 2022 – Winter 2023): Back up the archive-contents to avoid potential failures when refreshing the package archive. This is a factor that enhances the stability of Eask.
• Eask or emacs-eask/cli (Spring 2022 – Winter 2023 🏅🏅🏅🏅🏅🏅🏅🏅🏅): CLI for building, running, testing, and managing your Emacs Lisp dependencies. This tool is the successor to Cask, offering enhanced stability, cross-platform capability, and extensibility.
• Cask (Spring 2021 – Spring 2022 👷): Project management tool for Emacs. I’m the maintainer specifically responsible to Windows platform.

• jcs090218/nur (Fall 2024): Jen-Chieh’s Nix User Repository (NUR).
• eask2nix (Fall 2022 🏅): Convert Eask into Nix expressions.
• nixpkgs (Fall 2022 – Present ✨): Nix Packages collection & NixOS. I serve as the package maintainer for a small set of packages.

• vscode-ellsp (Winter 2023 🏅): Emacs Lisp languages support for Visual Studio Code.
• ellsp (Winter 2023): Language server implementation for Emacs Lisp. The emacs client (using lsp-mode) is also included; do M-x ellsp-register to enable it.
• vscode-shader (Fall 2023 🏅): Shader languages support for Visual Studio Code.
• shader-language-server (Summer 2023 – Fall 2023 🏅): Language server implementation for ShaderLab. It also provides support for various CG programming languages such as HLSL, GLSL, Cg, and more.
• grammarly-language-server (Summer 2022 ✨👷🔗): Grammarly for VS Code.
• unofficial-grammarly-language-server (Spring 2021 ✨👷🔗): Unofficial Grammarly extension. Forked from the original repository and maintained a version to ensure compatibility with various editors. This language server is now deprecated as the upstream has transitioned to the official API in 2022. Users are encouraged to use the newer grammarly-language-server instead.

Most Emacs packages are published on either MELPA 🏅 or JCS-ELPA 🏅, so I won’t list them explicitly.

• sideline-geiser (Winter 2024): Show Geiser result with sideline.
• sideline-racket (Winter 2024): Show racket result with sideline.
• sideline-sly (Winter 2024): Show SLY result with sideline.
• sideline-cider (Winter 2024): Show CIDER result with sideline.
• sideline-eros (Winter 2024): Show EROS result with sideline.
• markdown-toc (Winter 2024 👷): Generate a TOC in markdown file.
• ueval (Winter 2024): Universal Evaluation Utilities.
• rustic (Winter 2024 👷): Rust development environment.
• rust-mode (Fall 2024 👷): Emacs configuration for Rust.
• cognitive-complexity (Summer 2024): Show cognitive complexity of code in Emacs 29+ (treesit-based). This package is based on codemetrics but is designed to support the built-in treesit.el. (ported by @abougouffa ❤️)
• treesit-langs (Summer 2024): Language bundle for Emacs’s treesit.el. This package is based on tree-sitter-langs but is designed to support the built-in treesit.el.
• colorful-mode (Summer 2024 👷): 🎨Preview any color in your buffer.
• responsive-window (Summer 2024): Adapt to different screen sizes automatically.
• cogru.el (Summer 2024): Cogru plugin for Emacs.
• treesit-fold (Summer 2024): Code folding using treesit.el. (ported by @DevelopmentCool2449 ❤️)
• region-occurrences-highlighter (Summer 2024 👷): This emacs package implements a local minor mode that highlights occurrences of the current selected region.
• ansi-colorful (Summer 2024): Toggle render ansi-color.
• centaur-tabs (Summer 2024 👷): Emacs plugin aiming to become an aesthetic, modern-looking tabs plugin.
• auto-close-block (Summer 2024): Automatically close block.
• doom-dashboard (Spring 2024 👷): Doom Like style for emacs dashboard.
• sideline-load-cost (Spring 2024): Display load/require module size with sideline.
• guard-lf (Spring 2024): Guard large files.
• flymake-ziglint (Spring 2024): Flymake for ziglint.
• flycheck-ziglint (Spring 2024): Flycheck for ziglint.
• flymake-dart (Spring 2024): Flymake support for dart analyze.
• flycheck-dart (Spring 2024): Flycheck for dart analyze.
• zig-mode (Spring 2024 👷): Zig mode for Emacs.
• gptscript-mode (Spring 2024): Major mode for editing GPTScript natural language.
• dashboard-bm (Spring 2024 ✨👷): Visual Bookmarks (bm.el) for Dashboard.
• google-gemini (Spring 2024): Elisp library for the Google Gemini API.
• flycheck-rust (Spring 2024 👷): Better Rust/Cargo support for Flycheck.
• copilot.el (Spring 2024 👷): An unofficial Copilot plugin for Emacs.
• rainbow-csv (Winter 2023): 🌈 Highlight CSV and TSV spreadsheet files in different rainbow colors.
• qss-mode (Winter 2023): Major mode for Qt Style Sheets.
• sideline-eglot (Winter 2023): Show eglot information with sideline.
• company-emmet (Winter 2023): Company completion for emmet.
• ic (Winter 2023): Pretty print to debug. Inspired by the icecream package from the Python/PyPi community.
• jcs-template (Winter 2023): Template module for jcs-emacs.
• dart-mode (Fall 2023 👷): An Emacs mode for the Dart language
• php-mode (Fall 2023 👷): A powerful and flexible Emacs major mode for editing PHP scripts.
• elisp-tree-sitter (Fall 2023 👷): Emacs Lisp bindings for tree-sitter.
• tree-sitter-langs (Fall 2023 👷): Language bundle for Emacs’s tree-sitter package.
• blacken (Fall 2023 👷): Python Black for Emacs.
• anaconda-mode (Fall 2023 👷): Code navigation, documentation lookup and completion for Python.
• company-anaconda (Fall 2023 👷): Anaconda backend for company-mode.
• pythonic (Fall 2023 👷): Utility functions for writing pythonic emacs package.
• djangonaut (Fall 2023 👷): Emacs minor mode for Django.
• isortify (Fall 2023 👷): Isort for Emacs.
• pyenv-mode (Fall 2023 👷): Integrate pyenv with python-mode.
• chatgpt-sideline (Fall 2023): Sideline support for chatgpt.
• eglot-uniteai (Fall 2023 ✨👷): eglot client leveraging uniteai.
• lsp-uniteai (Fall 2023 ✨👷): lsp-mode client leveraging uniteai.
• eglot-shader (Fall 2023): eglot client leveraging shader-language-server.
• nerd-icons-buffer-menu (Summer 2023): Display nerd icons in buffer-menu.
• on.el (Summer 2023 🔗): Hooks for faster Emacs startup.
• deepl (Summer 2023): Elisp library for the DeepL API.
• jcs-poptip (Summer 2023): Generic popup tip.
• doxygen-asterisk (Summer 2023): Minor mode that helps you insert pair /* and */. This package is no longer supported as it has been superseded by the auto-close-block package.
• lsp-shader (Spring 2023 – Summer 2023): lsp-mode client leveraging shader-language-server.
• codemetrics (Spring 2023): Plugin shows complexity information. Inspired by CodeMetrics from the VSCode community. This plugin implements live calculation of the Cognitive Complexity metric, which was proposed by G. Ann Campbell in Cognitive Complexity - A new way of measuring understandability (c) SonarSource S.A. 2016-2021, Switzerland.
• jcs-echobar (Spring 2023): An echo-bar for jcs-emacs.
• jcs-frametitle (Spring 2023): A frame title for jcs-emacs.
• vs-comment-return (Spring 2023): Comment return like Visual Studio.
• flymake-elsa (Spring 2023): Flymake integration for Elsa — Emacs lisp static analyzer.
• dall-e (Spring 2023): Use DALL-E inside Emacs.
• chatgpt (Spring 2023): Use ChatGPT inside Emacs.
• codegpt (Spring 2023): Use GPT-3 inside Emacs. This project is inspired by the Code GPT: Chat & AI Agents from the VSCode community
• openai (Spring 2023): Elisp library for the OpenAI API.
• espuds (Spring 2023 👷): Common step definitions for Ecukes.
• ecukes (Spring 2023 👷): Cucumber for Emacs.
• sound-async (Winter 2022): Play sound asynchronously.
• block-travel (Winter 2022): Move to previous/next blank line. Drawn inspiration from Block Travel in the Atom community and Block Travel in the VSCode community.
• jcs-modeline (Winter 2022): A modeline for jcs-emacs.
• pkg-dm (Winter 2022): Package dependencies management. Emacs rarely encounters confusion regarding the dependency relationships between packages; this helps provide clarity.
• vc-refresh (Winter 2022): Refresh vc-state in certain events for better user experience.
• flycheck-deno (Winter 2022): Flycheck for deno-lint.
• ace-link-dashboard (Winter 2022 ✨👷): Ace-link for emacs-dashboard.
• easky (Winter 2022): Control Eask CLI in Emacs.
• eldoc-eask (Winter 2022): Eldoc support for Eask-file.
• company-eask (Winter 2022): Company backend for Eask-file.
• eask (Winter 2022): Core Eask APIs, for Eask CLI development.
• company-elisp-keywords (Winter 2022): Company completion for finder-known-keywords.
• cycle-case-style (Winter 2022): Cycle through case style (PascalCase, camelCase, etc).
• cycle-slash (Winter 2022): Cycle through slash, backslash, and double backslash.
• helafy (Winter 2022): minify/uglify/prettify contents.
• repos-window (Winter 2022): Reposition window when needed.
• company-paths (Winter 2022): A company backend for paths.
• vs-electric-spacing (Winter 2022): Add spacing around operators like Visual Studio.
• eval-mark (Winter 2022): Evaluate then deactive mark. The behavior of Emacs in this manner makes more sense to me.
• balanced-windows (Winter 2022): Keep windows balanced.
• ff-guard (Winter 2022): Create parent directory for non-existent file.
• fof (Winter 2022) Default configuration for ff-find-other-file.
• ffpc (Winter 2022): Find file in project or current directory.
• elenv (Winter 2022): Environment variable management.
• execrun (Winter 2022): Run through compilation-mode.
• editorconfig-emacs (Fall 2022 👷): EditorConfig plugin for Emacs.
• msgu (Fall 2022): Utility functions help output the messages.
• toggle-profiler (Fall 2022): Useful functions to interact with profiler.
• sideline-color (Fall 2022): Show color information with sideline.
• git-gutter (Fall 2022 👷): Emacs port of GitGutter which is Sublime Text Plugin.
• company-autoconf (Fall 2022 🔗): Completion backend for editing autoconf files in Emacs.
• company-kaomoji (Fall 2022): Company backend for Kaomoji.
• kaomoji.el (Fall 2022 🔗): Input kaomoji (顔文字) easily! ┌（┌ ＾o＾）┐ﾎﾓｫ
• company-makefile (Fall 2022 🔗): Emacs company completion backend for GNU Makefiles.
• company-cmd (Fall 2022 🔗): Emacs company-mode backend for windows DOS/batch scripts.
• company-powershell (Fall 2022 🔗): Autocompletion backend for powershell-mode in Emacs.
• company-dockerfile (Fall 2022 🔗): Add dockerfile keywords to company-mode keywords alist.
• ts-docstr (Fall 2022): A document string minor mode using tree-sitter.
• prt (Fall 2022): Progress Reporter Library.
• fussy (Summer 2022 👷): Emacs completion-style leveraging flx.
• vsc-multiple-cursors (Summer 2022): multiple-cursors integration behave like VSCode.
• sideline-blame (Summer 2022): Show blame messages with sideline.
• sideline-lsp (Summer 2022): Show lsp-mode information with sideline.
• sideline-flymake (Summer 2022): Show flymake errors with sideline.
• sideline-flycheck (Summer 2022): Show flycheck errors with sideline.
• sideline (Summer 2022): Show information on the side.
• gdscript-mode (Summer 2022 👷): An Emacs package to get GDScript support and syntax highlighting.
• javap-mode (Summer 2022 🔗): Show the ouput of javap when opening a jvm class file in Emacs.
• company-coffee (Summer 2022 🔗): Emacs add coffee keywords to company-keywords for completion.
• company-c-headers (Summer 2022 🔗): Auto-completion for C/C++ headers using Company.
• buffer-move (Summer 2022 🔗): easily swap buffers.
• noflet (Summer 2022 🔗): nic’s overriding flet, for fleting functions for the purpose of decorating them.
• eping (Summer 2022 🔗): An Emacs package that checks internet connectivity using ping.
• flymake-eask (Summer 2022): Eask support in Flymake.
• flycheck-eask (Summer 2022): Eask support in Flycheck.
• recentf-excl (Summer 2022): Exclude commands for recent files. Certain commands might inadvertently add files, resulting in unwanted entries in recentf. This package helps you address this issue.
• mbs (Summer 2022): Minibuffer stats.
• vertico-flx (Summer 2022): flx integration for vertico.
• flx-style (Spring 2022): Completion style for emacs-flx.
• vs-edit-mode (Spring 2022): Minor mode accomplish editing experience in Visual Studio.
• message-clean-mode (Spring 2022): Keep messages buffer clean. For an elisp developer, maintaining a clean *Messages* buffer is crucial for effectively tracking debug log information.
• fontawesome (Spring 2022 👷): FontAwesome utility.
• quick-peek (Spring 2022 🔗👷): Quick-peek inline-window library for Emacs.
• vs-revbuf (Spring 2022): Revert buffers like Visual Studio.
• eask-mode (Spring 2022): Major mode for editing Eask files.
• buffer-menu-project (Spring 2022): List buffers relative to project.
• buffer-menu-filter (Spring 2022): Filter buffer-menu items using fake header. While buffer-menu is a default method for switching between buffers, it lacks filtering capabilities. This package introduces that feature.
• electric-indent-sexp (Spring 2022): Automatically indent entire balanced expression block.
• fextern (Spring 2022): Record file external stats.
• auto-scroll-bar (Spring 2022): Automatically show/hide scroll-bars as needed.
• fuz-bin (Winter 2021): Similar to fuz.el but with precompiled binaries. I favor packages with precompiled binaries for an improved user experience.
• flx-rs (Winter 2021): emacs-flx in Rust using dynamic module. It packages the Rust library flx-rs and includes precompiled binaries, which are built and uploaded as artifacts through GitHub Actions.
• flxy (Winter 2021): flxy in Rust using dynamic module.
• sublime-fuzzy (Winter 2021): Fuzzy matching algorithm based on Sublime Text’s string search. Build sublime_fuzzy in Rust to Emacs loadable binaries.
• github-tags (Fall 2021): Retrieve tags information through GitHub API.
• company-box (Fall 2021 🔗): A company front-end with icons. Forked due to its challenging usability on Windows, incorporating numerous bug fixes, enhanced performance, and other improvements.
• ts-fold (Fall 2021): Code-folding using tree-sitter.
• hl-preproc (Fall 2021): Unhighlight invalid preprocessor region. This package uses meta-net to parse all define constants inside a csproj file.
• eldoc-meta-net (Fall 2021): Eldoc support for meta-net.
• company-emojify (Fall 2021): Company completion for Emojify.
• meta-view (Summer 2021): View metadata from .NET assemblies.
• company-meta-net (Summer 2021): company-mode backend for C# project.
• meta-net (Summer 2021): Parse .NET assembly’s XML.
• flex (Summer 2021): Flexible Matching Library. Algorithm is extracted from package ido-better-flex.
• liquidmetal (Summer 2021): A mimetic poly-alloy of the Quicksilver scoring algorithm. Ported from rmm5t/liquidmetal.
• logms (Summer 2021): Log message with clickable links to context.
• eglot-languagetool (Summer 2021): eglot client leveraging LanguageTool Language Server.
• lsp-languagetool (Summer 2021): lsp-mode client leveraging LanguageTool Language Server.
• eglot-ltex (Summer 2021): Eglot client leveraging LTEX Language Server.
• lsp-ltex (Summer 2021): lsp-mode client leveraging LTEX Language Server.
• flymake-languagetool (Summer 2021): Flymake support for LanguageTool.
• flycheck-languagetool (Summer 2021): Flycheck support for LanguageTool.
• auth-source-keytar (Summer 2021): Integrate auth-source with keytar.
• applescript-mode (Spring 2021 👷): Emacs mode for editing AppleScript.
• send-to-osx-grammarly (Spring 2021): An Emacs extension to send a text to/from Grammarly.
• eglot-grammarly (Spring 2021): eglot client leveraging grammarly-language-server.
• lsp-grammarly (Spring 2021): lsp-mode client leveraging grammarly-language-server.
• flycheck-google-cpplint (Spring 2021 👷): Google C++ Style checker for Flycheck.
• flymake-google-cpplint (Spring 2021 👷): Help to comply with the Google C++ Style Guide on Emacs with flymake.
• flymake-cppcheck (Spring 2021 👷): Cppcheck for Emacs with flymake.
• emacs-flymake-perlcritic (Spring 2021 👷): Run Perl::Critic static analysis “While U Type” via Emacs Flymake.
• flymake-phpcs (Spring 2021 👷): PHP CodeSniffer for Emacs with flymake.
• emacs-flymake-phpcs (Spring 2021 👷): Glue to bind Emacs Flymake mode to PHP_CodeSniffer static analysis.
• emacs-flymake-cursor (Spring 2021 👷): Display flymake error for the current line on the minibuffer.
• fuzzy-el (Spring 2021 – Present 👷): Fuzzy matching utilities designed for GNU Emacs, originally created for auto-complete.
• keytar (Spring 2021): Emacs Lisp interface for keytar-cli.
• lsp-grammarly-un (Spring 2021): lsp-mode client leveraging unofficial-grammarly-language-server.
• watch-cursor (Winter 2020): Display cursor from all live windows.
• docstr (Winter 2020): A document string minor mode.
• modablist (Winter 2020): Modifiable tabulated-list extension.
• scroll-text (Winter 2020): An enjoyable endeavor for animating scrolling text within an Emacs buffer.
• npm-pkgs (Winter 2020): An npm packages client.
• preview-it (Winter 2020): Preview anything at point.
• undo-tree-vf (Winter 2020): Visualizer follow mode for undo-tree.
• quelpa-leaf (Winter 2020): Emacs quelpa handler for leaf.
• quelpa (Fall 2020 – Present 👷): The package.el-compatible package manager for Emacs uses the MELPA’s format.
• auto-complete (Fall 2020 – Present 👷): An Intelligent auto-completion extension for Emacs.
• un-mini (Fall 2020): Automatically close minibuffer after it loses focus.
• ivy-file-preview (Fall 2020): Preview the current ivy file selection.
• ivy-describe-modes (Fall 2020): Ivy interface to describe-mode. Inspired by helm-describe-modes.
• flymake-grammarly (Fall 2020): Flymake support for Grammarly.
• lsp-focus (Fall 2020 👷): lsp-mode ❤️ focus.
• helm-lsp (Fall 2020 👷): lsp-mode ❤️ helm.
• lsp-ivy (Fall 2020 👷): lsp-mode ❤️ ivy.
• lsp-origami (Fall 2020 👷): lsp-mode ❤️ origami.el.
• dap-mode (Fall 2020 👷): Emacs ❤️ Debug Adapter Protocol.
• lsp-ui (Fall 2020 👷): UI integrations for lsp-mode.
• lsp-mode (Fall 2020 👷): Emacs client/library for the Language Server Protocol.
• license-templates (Fall 2020): Create LICENSE using GitHub API.
• atl-long-lines (Fall 2020): Turn off truncate-lines when the line is long.
• atl-markup (Fall 2020): Automatically truncate lines for markup languages.
• cursor-preview (Fall 2020): Preivew cursor movement while executing command interactively.
• impatient-showdown (Fall 2020): Preview markdown buffer live over HTTP.
• auto-highlight-symbol (Fall 2020 👷): Automatic highlighting current symbol minor mode.
• better-scroll (Fall 2020): Improve user experience when scrolling window.
• fill-page (Fall 2020): Fill the buffer so you don’t see empty lines at the end.
• undersea-theme (Fall 2020): Theme styled after undersea imagery.
• origami.el (Summer 2020 🔗): A folding minor mode for Emacs. This project is a Regular Expression-based solution, but it became deprecated following the creation of ts-fold.
• popup-el (Summer 2020 – Present 👷): Visual Popup Interface Library for Emacs. It’s used with auto-complete.
• transwin (Summer 2020): Make window/frame transparent.
• helm-searcher (Summer 2020): Helm interface to use searcher.
• ivy-searcher (Summer 2020): Ivy interface to use searcher.
• searcher (Summer 2020): An alternative to ag, rg, grep, and others, written in pure elisp for enhanced portability.
• quickrun (Summer 2020 👷): Run command quickly. This packages is inspired quickrun.vim.
• zoom-window (Spring 2020 👷): Zoom and Unzoom window.
• sound-wav (Spring 2020 👷): Play wav file.
• emp (Spring 2020): Emacs Music Playlist.
• manage-minor-mode-table (Spring 2020): Manage minor-modes in table. Expands on the functionality of the package manage-minor-mode.
• helm-themes (Spring 2020 👷): Emacs theme selection with helm interface.
• helm-gtags (Spring 2020 👷): GNU GLOBAL helm interface.
• helm-ag (Spring 2020 👷): The silver searcher with helm interface.
• emoji-github (Spring 2020): Display list of GitHub’s emoji. (cheat sheet)
• buffer-wrap (Spring 2020): Wrap the beginning and the end of buffer.
• dashboard-ls (Spring 2020): Display files/directories in current directory on Dashboard.
• manage-minor-mode (Spring 2020 👷): Manage your minor-mode on the dedicated interface buffer.
• popwin (Spring 2020 👷): Popup Window Manager for Emacs.
• undohist (Spring 2020 👷): Persistent Undo History for GNU Emacs.
• yascroll (Spring 2020 👷): Yet Another Scroll Bar Mode.
• company-quickhelp-terminal (Winter 2019): Terminal support for company-quickhelp.
• ffmpeg-player (Winter 2019): Play video using ffmpeg. The performance is notably poor as it plays the video frame by frame, leading to significant file I/O (including memory) demands. However, this remains the sole solution for playing videos within Emacs!
• parse-it (Winter 2019): Simple Parser in Emacs Lisp. It provides support for over 25 languages (e.g. C, C++, C#, Python, Lua, etc), but its performance is noticeably slow as it operates on top of the elisp interpreter.
• flycheck-grammarly (Winter 2019): Grammarly support for Flycheck.
• grammarly (Winter 2019): Grammarly API interface. (reverse-engineered solution)
• tabulated-list-search (Winter 2019): Provide filtering/searching tabulated-list interface.
• reveal-in-folder (Winter 2019): Reveal current file/directory in folder.
• define-it (Winter 2019): Define, translate, wiki the word. Inspired by Amazon Kindle’s reading experiences.
• multi-shell (Winter 2019): Managing multiple shell buffers.
• vs-light-theme (Fall 2019): Visual Studio IDE light theme.
• vs-dark-theme (Fall 2019): Visual Studio IDE dark theme.
• diminish-buffer (Fall 2019): Diminish (hide) buffers from buffer-menu.
• company-fuzzy (Fall 2019): Fuzzy matching for company-mode.
• helm-fuzzy (Fall 2019): Fuzzy matching for helm source.
• marquee-header (Fall 2019): Code interface for displaying marquee in header.
• alt-codes (Fall 2019): Insert alt codes using meta key.
• haxe-mode (Fall 2019): Major mode for editing Haxe files.
• jayces-mode (Fall 2019): Major mode for editing JayCeS file.
• csharp-mode (Fall 2019 👷): A major-mode for editing C# in emacs.
• dashboard (Summer 2019 – Present 👷): An extensible Emacs startup screen showing you what’s most important.
• indent-control (Summer 2019): Generic control the indentation level for each mode.
• show-eol (Summer 2019): Show end of line (EOL) symbol in buffer. Derived inspiration from the built-in functionality of the editor Notepad++.
• helm-file-preview (Summer 2019): Preview the current helm file selection.
• goto-char-preview (Summer 2019): Preview character when executing goto-char command.
• goto-line-preview (Spring 2019): Preview line when executing goto-line command.
• isearch-project (Spring 2019): Incremental search through the whole project.
• toggle-quotes-plus (Spring 2019): Simple quote toggler that cycle through ", ', and `.
• file-header (Winter 2018): Highly customizable self design file header.
• com-css-sort (Winter 2018): Common way of sorting the CSS attributes.
• htmltagwrap (Winter 2018): Wraps a chunk of HTML code in tags. Inspired by the htmltagwrap from the VSCode community.
• auto-close-tag (Winter 2018): Automatically add HTML/XML close tag. Inspired by the Auto Close Tag from the VSCode community.
• auto-rename-tag (Winter 2018): Automatically rename paired HTML/XML tag. Inspired by Auto Rename Tag from the VSCode community.
• use-ttf (Summer 2018): Keep font consistency across different OSs.
• project-abbrev (Summer 2018): Customize your own abbreviation expansion in the project.
• line-reminder (Summer 2018): Line annotation for changed and saved lines.
• organize-imports-java (Summer 2018): Automatically organize imports in Java code. It has been deprecated with the advent of the Language Server Protocol.

Package Archive (ELPA)

• jcs-elpa (Winter 2021 – Present): Jen-Chieh Shen’s (my own) ELPA; currently featuring 200+ packages.
• melpa (Fall 2020 – Winter 2023 ✨): Recipes and build machinery for the biggest Emacs package repo. MELPA stands for “Milkypostman’s Emacs Lisp Package Archive,” and I am among the top 10 contributors to the repository.

Distribution

• jcs-emacs (Summer 2015 – Present): Emacs distribution that is designed to function smoothly across all operating systems, , delivering exceptional performance, especially on legacy Windows systems.

• minify-dir (Spring 2019 🏅): Minify all files within a directory. Another Node.js website minifier created initially for the static site generator — SiraDoc.
• JCSBat_Util (Winter 2016 – Present): Some handy batch files for my workflow as programmer. (Windows)

• keytar-cli (Spring 2021 🏅): CLI for keytar. It was initially used with lsp-grammarly, but it became obsolete after the upstream grammarly-language-server had adapted the official API.
• reverse_shell (Spring 2019): Reverse shell implemented in Python.

• shakespeare-monkey (Spring 2024 – Summer 2024): First attempt at implementing a Genetic Algorithm to demonstrate the Infinite Monkey Theorem in Rust.

• SiraDoc (Fall 2021 🏅): A static documentation generator for scripting manuals! This was initially developed for several of my game frameworks, including JCSUnity, JCSEgret, CCosQuick, etc.

• setup-qob (Winter 2024 🏅): Install Qob for GitHub Actions workflow.
• tree-sitter-langs/update-grammars.yml (Spring 2024): Automatically update the TreeSitter grammars (submodules) by opening pull requests. Unlike the typical update_submodules.yml process, updating individual grammars is more complex, hence the importance of splitting it into separate modules.
• melpa/review-pr.yml (Spring 2024): Automatically review and comment on new package pull requests on MELPA. I’ve submitted the pull request in melpa#8904. This marks the second attempt to resolve the issue in melpa#6714. This solution is significantly simpler, relying solely on GitHub Actions, which improves the chances of it being merged.
• update_submodules.yml (Spring 2024): Automatically update all the submodules within the repository and update the repository by opening a pull request. This workflow is used across several projects, such as emacs-eask/cli, jcs-profile (this website), and more.
• setup-emacs-windows/update-stable.yml (Spring 2024): Automatically locate the latest Emacs’ version and update the code through a pull request (PR).
• setup-emacs-windows/update-snapshot.yml (Spring 2024): Automatically locate the most recent Emacs’ snapshot and update the code through a pull request (PR).
• setup-lem (Fall 2023 🏅): Install Lem for GitHub Actions workflow.
• github-push-action (Summer 2022 ✨🔗🏅): Forked from ad-m/github-push-action, this fork includes the rebase option tailored for my automation workflows.
• setup-emacs (Summer 2022 🏅): Github action which installs a given Emacs version. This project aims to replace purcell/setup-emacs by combining the two GitHub Actions — purcell/setup-emacs and setup-emacs-windows — into one. As a result, it now supports all commonly used operating systems.
• setup-eask (Spring 2022 🏅): Install Eask for Github Actions workflow.
• unity-verify-code (Fall 2021 🏅): An email parser to get 6 digit verification code to bypass TFA.
• unity-license-activate (Fall 2021 🏅): Activate Unity’s personal license through CLI.
• setup-emacs-windows (Fall 2020 🏅): A [Github Action][] that installs a specific emacs version. This project draws inspiration from purcell/setup-emacs but is specifically dedicated to supporting legacy Windows systems.
• package-bot (Spring 2020 – Fall 2020): Review new package PRs on MELPA automatically. Requested by the community, refer to melpa#6714. While it wasn’t ultimately accepted, it propelled the community towards a better alternative — melpazoid.

• aws-toolkit-emacs (Winter 2023): A plugin for interacting with AWS from Emacs editor.
• jcs-lem (Summer 2023 – Present): My personal lem configuration files. Lem is still in its early stages, particularly on Windows systems.
• Prevo (Summer 2021): Preview GameObject using preview window.
• 8comic (Fall 2020): Use 8comic to read manga.
• UCTooth (Summer 2020 💸): A cross-platform Bluetooth plugin for Unity, implemented in the native code of each platform.
• swagger-it (Spring 2020): Automatically generate the swagger.io yaml file for your project.
• CCosQuick (Winter 2019 – Summer 2020 💸): Prototype your game easily with component driven library built on top of Cocos Creator.
• MGDP (Fall 2019 – Winter 2019): Quaver is essentially a DJMax clone; hence, I’m uncertain whether to proceed with this project.
  • Client (closed-source): Utilizing the Unity Engine, this game client aims to implement the gameplay aspect of the MGDP project.
  • DevTool (closed-source): A simple desktop application assists me in generating music archive, which are then deployed on the server.
  • DevelopmentKit (closed source): Empower MGDP game developers with the capability to create their own music games and publish them on the MGDP platform.
• JCSUE (Fall 2017): Quickly construct your game by utilizing multiple components and predefined default settings.
• jcs-vim (Winter 2016): My personal vim configuration files. This is my initial experience with Vim, and I’m interested in exploring NeoVim in the future.

• tree-sitter-actionscript (Spring 2021): ActionScript grammar for tree-sitter. Rileran completed the project earlier — Rileran/tree-sitter-actionscript — thus, there is no need to continue the project any further. For the record, Rileran’s project takes inspiration from my project!
• work-time (Spring 2021): How long have you been working? I’m uncertain about its current value, as it could potentially be substituted with wakatime and hammy.el.
• organize-imports-python (Spring 2021): Automatically organize imports in Python code. No reason to create this package anymore due to the advent of the Language Server Protocol.
• vlc-player (Winter 2019): Play video using VLC. I can’t recall the precise reason for abandoning this. My best assumption is that VLC doesn’t support the necessary options for stopping the video, prompting me to opt for ffmpeg instead.
• JCSEgret (Winter 2018 💸): A library designed for efficient game production using the Egret engine as its foundation. The project was initiated during the course of work but is no longer in use as the Egret engine became obsolete following their bankruptcy.