Hi, I'm a 19 year old developer that specializes in Unity systems, web, and various other tools. I have experience with programming languages that range from Scratch to C with a passion to try out anything new.
I've been programming since the fifth grade and have been working on projects almost every day. I've released a bunch of my projects which you can find here on my website.
The Unity Asset Store offered me my first experience with making money from something I love doing. Many people around the world purchase pre-made assets and plugins for their Unity projects including companies and especially the mobile game industry.
My first asset I published to the Asset store was inspired by those annoying "desktop buddy" programs where a character may run around the screen and interact with various parts of it. Rainity is a package that allows you to run a Unity scene in the background of your desktop with full mouse interaction, program and file interaction, an API and more.
My best selling Asset titled PSXEffects is a graphics package designed for game developers who want to add a retro touch to their game. PSXEffects imitates the original PlayStation graphics as accurately as possible while still providing loads of customization through post-processing and material editing. Customers of this asset are appreciative of the constant features added and customer service that I've provided.
To answer one of Unity's most requested features, I built Menute to solve the problem of efficiently searching for assets and objects in a Unity Project. Menute is a quick-action search bar that can be activated by pressing a key. It searches the entire project for scene GameObjects, Assets, and toolbar items for the user to quickly select what they're looking for.
Testing out the single-but-many-use asset model, I created Procedural Cracks. The reason I classify it as such is that there are a lot of packages on the Asset Store that specialize in specific aspects of game design, which Procedural Cracks falls under. This asset is an easy to use shader that generates a high-quality parallax cracks effect that can be placed on any surface. What's cool about this is that it does not modify any geometry and runs fully on the GPU, making it lighting fast.
What started out as a small experiment to see if a CHIP-8 interpreter could run on a Texas Instruments calculator turned into a fully-fledged portable project. Chip-84, originally written for the TI-84 Plus CE calculator in C, is a program that emulates CHIP-8 and SCHIP-8 (or Super CHIP-8) programs directly on the calculator.
With the help of the Cemetech community and this C toolchain for the TI-84 PCE, I was able to learn how to program my $5 garage sale calculator in about a day. I started by making a 3D wireframe cube render on the screen which could be rotated using the calculator's directional keys. I then made a small platformer game and learned about sprites on the TI-84 and how small these projects must be. Chip-84 was the ultimate test of my knowledge of not only the calculator, but the CHIP-8 and SCHIP-8 interpretation as well.
Using many different resources from the internet and my small previous experience with CHIP-8 interpreters, I whipped up a small program called Chip-84 and posted it on the Cemetech forums. As time went on, I made lots of fixes, added SCHIP-8 support, lots of settings such as interpretation speed, colors, key-mapping and more. After the emulator seemed to be at its peak, I decided it would be a cool idea to try to port Chip-84 to as many different platforms as possible.
I started off by porting it to the Unity game engine. Unity uses C# as its main programming language, so I had to translate most of the Chip-84 code from C to C#. Using Unity allowed me to display graphics in a 3D space as opposed to a 2D screen. I got a little carried away with this idea and made it possible to display it on different 3D models such as a CRT TV, a road sign, graph paper, and a hologram.
My next mission was to port it to the Nintendo DS Lite, copying the base code for the emulator and conforming it to libnds. I added a touch keypad on the bottom screen and the program was able to run just like the calculator version. This was surprisingly easy given I had some previous experience with devkitPro and libnds. Having Chip-84 in a portable environment other than the TI-84 PCE was exciting to see come to life.
Since Scratch was my first introduction to programming, I thought it would be interesting to try to remake Chip-84 in Scratch. Anyone who has used Scratch before knows it's not the fastest environment to run lots of code whatsoever, so making Chip-84 run well was a challenge. On top of that, I had to refactor a lot of the core to support Scratch's lists starting at 1 instead of 0. This took a whole lot of thinking and modifying how online CHIP-8 resources referenced their interpreters. However, I was able to make it work even with a cycles per frame modifier just like the TI-84 PCE version.
Every emulator in history needs a Windows version, right? Chip-84 SDL Edition was the last port of Chip-84 where I used SDL for the first time while keeping all the code in C. This version of the emulator ran amazingly fast and accurately conformed to most of the "accurate" CHIP-8 emulators out there.
Some other attempts of porting Chip-84 included running it in Garry's Mod and Discord. As they both worked as emulators, however, these two platforms were extremely impractical and didn't run at the speed needed by the interpreter.
With all of my interest invested in CHIP-8, I decided to write some of my own programs using Octo, a CHIP-8 IDE. The first program I made was a simple demo consisting of my Instagram handle "ckosmic" scrolling down the screen and looping around to the top once it reached the bottom. This was just a small test to see what the IDE was capable of. My next program, titled "TRAFFIC" was a small game where you control a space ship and avoid hitting other space ships and walls. This again was just a small project, but it was a playable game and I was able to use it as a test program for a lot of my emulator's ports.
In the iOS jailbreaking community, tweaks to the phone's functions and UI are what makes jailbreaking worth it. Like usual, I was immediately fascinated with the fact that jailbreaking iPhones strongly pushed the limits of the known-to-be stubborn nature of an Apple Product. After a long time of just using other people's tweaks, I decided to try it out for myself by teaching myself a little bit of Objective-C and getting to town.
NoRisk was the first tweak I made and released to the public. This was to solve a problem I personally faced where sometimes I would accidentally or actually end up texting the wrong person the wrong thing, spawning some very awkward moments. This tweak makes it so any user-specified contact number or email that's either in a group conversation or one-on-one in iMessage gets highlighted red to hopefully prevent accidental sends. I got a lot of verbal support from this on Reddit, which is where I released the tweak for people to check out.
I enjoyed the whole experience and how surprisingly easy making tweaks was after the huge hurdle of Objective-C's super confusing syntax. I then made another tweak called BrightCam. This was designed to emulate the full-brightness camera from some Android phones' cameras such as the Samsung Galaxy phones. This makes it so every time you open the default camera app, the screen's brightness is turned up to the max and restored when exiting the app.
To celebrate getting my new iPhone X for jailbreaking purposes, I wanted to take advantage of the OLED screen and iOS 13's brand new dark mode even further. The best way I saw to do this was to black out the home screen and replace most solid-colored items with thin outlined ones. The first step was the creation of WireDock. This transforms the home screen's dock to an outline that is completely customizable via the settings app. This was just step one to making the perfect home screen setup.
The next step was to make the home screen icons look the same way as the dock, so I made a tweak called WireIcons. This tweak adds a colored border to app icons that again are completely customizable via the settings app. The outline added to the icons made it possible to change the size of the icon's image while keeping the outline the same size. This is important for what I was about to do next.
Theming iOS' home screen is what jailbreaking is mainly known for. This involves changing icon images throughout iOS to something new. This is where my theme Wires comes in. To continue with the outline OLED look for my home screen, all the icons I made were "wire" versions of their original ones. I designed over 200 icons in total which took me several weeks to complete. After making all the icons in white, I thought to myself, "why didn't I make these all colored at first?" It was pretty disappointing to have to go back to all the icons and assign them an individual color. But then I remembered: "wait, I'm a developer. I can just automate this." So discovering the iTunes store's search API I was able to make a program that retrieves each app's icon by its bundle identifier and colors the associated icon using its most frequent color. Within less than a day I recolored all the icons I already made, making it possible to use either a white or multi-colored version of the icon set. Finally my home screen was complete.
What started as a joke turned into a fully-fledged virus-like program for school computers. CSFun was a program I wrote that allowed you to turn on various screen effects, mouse cursor annoyances, and program openers all at once to simulate what looks like a virus. The program used Windows API to copy parts of the screen, change its colors, and paste it in a different part of the screen. Some CSFun programs scaled window sizes in a wave-like function, moved the mouse around, corrupted directories and more.
CSFun, originally written in Java, CSFun2 was a successor to the original now written in C#. This allowed for a more modular design using plugins (called Subs) to be imported to run on CSFun2. Plugins are also written in C# with their own settings and functionality to be taken into account when used in CSFun2.
In my introductory C++ class in community college, we were assigned a final project very early in the semester that had to be a game, but it could be any game. I've always had a history of wanting to make something cool and showing it off to be wow'd, so I wanted to start as fast as possible. With my little-to-none experience with C++, by the end of the semester I had created a game called LowEye.
The first thought that popped into my mind was to make something using no external libraries whatsoever to maximize portability... well among Windows machines, but we'll get to that in a second. My goal was to make a game engine that ran directly in the console. With help from lots of Googling, I successfully created a game engine that ran exactly how I wanted using Windows API functions to scale and re-fontisize the console. The engine is capable of rendering 72 colors using sprites, draw functions, and shape drawing functions as well as taking keyboard input and saving and loading.
Sprites are loaded through .bmp 24-bit Bitmap files. When loaded into memory, out of the 72 avaiable colors, the closest one to each pixel is chosen to be in the sprite object. Sprites are able to be any size and could be drawn anywhere: either on the UI buffer or the "screen" buffer, also known as the environment buffer. For transparent sprites, a specific color is used (rgb(69, 4, 20)) to denote transparency. The engine's font system is also powered by sprites and are loaded when the program is run.
Following lodev's Raycaster tutorial, I created the base of the game for the player to move around in a faux-3D environment. Building upon this raycaster system, I implemented textured walls, floors, and ceilings as well as opening/closing doors, 3D sprites, player interaction and more. With the power of what I had made, it was time to add mechanics to the game to make it actually enjoyable.
The main goal of the game is to fight enemies to reach the final boss at the end of the map. The battle system is the most important part to make the game fun for anyone playing it. Using items and abilites you can find throughout the map, you can battle enemies one by one to level yourself up enough to gain the strength and defense to defeat the final boss. The turn-based battle system featured pretty cool graphics of the enemy, an easy to use battle menu, nicely displayed status bars and more.
Presenting LowEye was a great experience mostly because I couldn't fit all that I wanted to talk about in the maximum of two minutes, so it had to have been good. I got the main points of both the engine and the game down, and blew some people away while also seeing other people's cool games that they created. It was a fantastic learning experience and a great product that I was happy to put together.