Home

Luminous & Exalted Wynaut Line

Luminous variants of Wynaut and Wobbuffet with bright mint skin.

Exalted variants of Wynaut and Wobbuffet with golden skin and a silver tail.

Originally made for Callisto shiny variants.

Luminous & Exalted Murkrow Line

Luminous variants of Murkrow and Honchkrow with bright cyan plumage.

Exalted variants of Murkrow and Honchkrow with grayscale "noir" styling and bright red accents.

Originally made for Callisto shiny variants.

Luminous & Exalted Aipom Line

Luminous variants of Aipom and Ambipom based on Snow Monkeys.

Exalted variants of Aipom and Ambipom with glowing blue fur.

Originally made for Callisto shiny variants.

Cobblemon Model Viewer

Interactive 3D viewport that renders Cobblemon Bedrock models (.geo.json) with their textures and overlay layers. Pass a species and aspects — the resolver automatically selects the right model, base texture, and any emissive or translucent overlays. Drag to rotate · scroll to zoom · auto-rotates.

Resolver system

Resolver JSON files in public/cobblemon/bedrock/pokemon/resolvers/ map aspect combinations to models and textures. Each resolver has an order field; multiple resolvers per species are loaded and sorted by it (lowest = highest priority). Variation matching requires all listed aspects to be present in the active set, preferring more specific matches (more aspects = higher score), with resolver order as a tiebreaker. Layers are typed as emissive, translucent, or emissive + additive (a 0–1 strength number), each resolved to a public URL via cobblemon: namespace stripping.

Bedrock geometry loader

A custom loader parses .geo.json without any third-party Bedrock library:

• Coordinate mapping — Minecraft +Z south maps to Three.js −Z, so all Z positions are negated. Bone rotations use (+rx, −ry, −rz) with ZYX Euler order to match Blockbench's internal Z-negated frame (conjugated by an implicit Y180 flip relative to Blockbench's own loader).
• Bone hierarchy — each bone becomes a THREE.Group positioned at its pivot. Cube meshes are offset by −pivot so their vertices land at model-space coordinates regardless of nesting depth. Cube-level rotations get their own wrapper group positioned at the cube pivot.
• Box-UV unfolding — the side strip follows [west][front][east][back] order (not the Java skin convention). Bottom-face UV winding is corrected by forcing BL = (x1, z1) and inverting the flipU flag relative to the other faces.
• mirror_uv — mirrors east/west rects AND flips the U axis on all six faces, matching Blockbench's source behavior. Used on mirrored cubes like Pidgeot's wings and eyes.
• Per-face UV — per-face uv / uv_size specs are supported alongside box-UV; inflate pads all six faces outward.

Material and layer blending

Geometry is built once and shared across the base and all overlay layers — only materials differ. Layer blending:

• Base — alphaTest cutout, depth write enabled.
• Emissive — full-bright (not additive); NormalBlending with cutout alpha and no depth write. MeshBasicMaterial is already unlit, so AdditiveBlending would only saturate toward white.
• Emissive + additive: <number> — AdditiveBlending with opacity set to the 0–1 strength value, scaling how much the layer adds to the scene. opacity multiplies the source alpha before the GPU blend equation, so it's a direct brightness control with no shader changes needed. Used for Lapras's crystal tips (0.6).
• Translucent — NormalBlending with full alpha channel, no depth write.

Hello, World

Welcome to my corner of the internet.

This site is built with Next.js 15, Tailwind CSS v4 (Dracula theme), and React Three Fiber for 3D Cobblemon model rendering.

What's here

• Portfolio — projects I've worked on, including interactive 3D demos
• Blog — occasional write-ups on things I find interesting

What's coming

• Full Cobblemon model gallery with animations
• Deeper write-ups on Bedrock model format internals
• More projects as I build them

Stay tuned.

Luminous & Exalted Bonsly Line

Luminous variants of Bonsly and Sudowoodo based on the Utah Juniper.

Exalted variants of Bonsly and Sudowoodo based on Glow Berries.

Originally made for Callisto shiny variants.

Luminous & Exalted Natu Line

Luminous variants of Natu and Xatu with bright red and yellow plumage.

Exalted variants of Natu and Xatu with gilded plumage and glowing eyes.

Originally made for Callisto shiny variants.

Halloween Conkeldurr

A ghostly variant of Conkeldurr that haunts graveyards, dragging huge, cracked tombstones.

Originally made for the Halloween 2025 event on Roanoke Diamond.

Halloween Venusaur

A spooky variant of Venusaur with a huge Marigold on its back.

Originally made for the Halloween 2025 event on Roanoke Diamond.

Pinkan Weedle Line

Regional variants of Weedle, Kakuna, and Beedrill from Pinkan Island.

Originally made for the Fall 2025 Pinkan Island refresh on Roanoke Diamond.

Pinkan Poliwag Line

Regional variants of Poliwag, Poliwhirl, Poliwrath, and Politoed from Pinkan Island.

Originally made for the Fall 2025 Pinkan Island refresh on Roanoke Diamond.

Pinkan Pidgey Line

Regional variants of Pidgey, Pidgeotto, and Pidgeot from Pinkan Island.

Originally made for the Fall 2025 Pinkan Island refresh on Roanoke Diamond.

Pinkan Caterpie Line

Regional variants of Caterpie, Metapod, and Butterfree from Pinkan Island.

Originally made for the Fall 2025 Pinkan Island refresh on Roanoke Diamond.

Painted Mankey Line

Messy variants of Mankey, Primeape, and Annihilape that painted themselved to look more threatening.

Originally made Roanoke Diamond custom starters.

Thunderbird Zapdos

A mythological variant of Zapdos inspired by the great Thunderbird of legend, with sweeping storm-dark plumage.

Originally made for the Summer 2025 Texture Jam on Roanoke Diamond.

Hylian Aegislash

A heroic variant of Aegislash from a faraway land.

Originally made for the Summer 2025 Texture Jam on Roanoke Diamond.

Crystal Lapras

A glacial variant of Lapras with glowing crystals emerging from it's back and head.

Originally made for the Summer 2025 Texture Jam on Roanoke Diamond.

Pride Ho-Oh

A radiant variant of Ho-Oh with a iridescent plumage and bright rainbow feathers.

Originally made for the Pride 2025 event on Roanoke Diamond.

Knight in Shining Armarouge

A valiant Armarouge clad in gleaming white armor.

Originally made for the Spring 2025 Texture Jam on Roanoke Diamond.

Moon-Rabbit Diggersby

A cosmic variant of Diggersby with floating comet arms.

Originally made for the Spring 2025 Texture Jam on Roanoke Diamond.

Atlantid Relicanth

An ancient deep-sea variant of Relicanth with arcane mechanical markings.

Originally made for the Spring 2025 Texture Jam on Roanoke Diamond.

Crypt Raider Level

This project follows up on the previous: Unreal Engine 5 - Rocky Forest Environment. While designing that level I was focusing on tooling for landscape and foliage design. In contrast, this project was to design an almost entirely indoors and man-made location.

This level was created while following the gamedev.tv course Unreal 5.0 C++ Developer. I used a modular dungeon asset pack to build out the dungeon and crypt, and used a collection of boulder models to construct the cave interior. The level has interactable game elements in the form of objects you can pick up and move around. These grabbable objects are used in two puzzles: unlocking the secret spiral stair entrance to the cave, and leaving the cave crypt with the Holy Grail without triggering a trap!

I'm still finishing up the above course, and will likely have more UE5 projects to post here. Stay tuned!

Unreal Engine 5 - Rocky Forest Environment

The release of Unreal Engine 5 was momentous. With the dynamic LODs provided by Nanite and the automatic shadows/AO generated by Lumen, level design is easier than it's ever been. Inspired by these new tools, I set out to learn the basics of environment design in UE5.

This level was created while following the gamedev.tv course Unreal Environment Design. I started with a basic landscape brush pass, then blocked out the playable area using cliffs and rocks available on Quixel Mixer. Once the landscape and boundaries were in place, trees and foliage were placed and painted around the scene. Finally, a few unique assets and decals were added to give the centerpiece boulder more intrigue.

I'm really excited at the new possibilities UE5 brings. Look forward to similar projects posted here!

simpleterm

simpleterm is a bespoke fake terminal written in pure Rust. It lets you create a window with specified size, font, and colors, then display text in that window and get input from the user.

Each call to the terminal returns execution once some condition is met, so you can easily write a complex script of interactions with the user. The terminal functions even include methods to update the terminal's size, colors, and font on the fly!

I told you to expect more Rust here — not a month later and I've got a second public crate! I started this almost immediately after finishing intfic after growing frustrated with the lacking support for terminal colors on Windows. By displaying my story in a custom window, I could ensure that it looked relatively the same across all operating systems.

So, in the interest of modularity I set out to make a fake terminal that did a few things very well, and I think I succeeded with those goals in simpleterm! I used piston_window as the backend and did run into some trouble with the way they process fonts and characters. For example, trying to load two sets of glyphs will crash the program unless you reload them right before use! I ended up only loading one at a time, and adding some code to toggle whether the terminal is in "text" mode or "art" mode.

Now that simpleterm is done, I'll be looking to incorporate it with intfic to create intfic_window, so stay tuned!

• Crate: https://crates.io/crates/simpleterm
• Docs: https://docs.rs/simpleterm/
• Repo: https://github.com/tjhaskel/rust_simpleterm

intfic

intfic is a framework that allows you to write a branching story with minimal code. It was made using pure Rust and uses a custom Story File Markup specification.

This was my first public Rust crate, and the first open-source project I've released in general! It came after months of learning Rust online with the official book.

To test my skills after completing the book, I set out to create a short narrative game where the player would run away from home and explore a mysterious land. Naturally I began to find building the tools to make the game much more interesting than writing the story itself, and intfic was the result! If I ever do get around to writing that story I can do it all with the Story File Markup system, including setting environment variables, having conditional text and options, and linking different files together from anywhere in the story.

This project was a great introduction to Rust's command line and parsing tools, and after everything I can safely say I'm a huge fan of the language. Look forward to many more Rust projects here in the future!

• Crate: https://crates.io/crates/intfic
• Docs: https://docs.rs/intfic/
• Repo: https://github.com/tjhaskel/rust_intfic

Relative Evil

"Relative Evil" was my submission to Shacknews Jam: Do it IV Shacknews. The theme of this jam was "Be Relatively Evil", and my goal for the game was to base it all around judging the relative "evil" of other people. At the end of the game the player has their own relative "evil" judged based on their choices. The classic trolley problem serves as a perfect framing to explore these comparisons; even more so when you have to decide very quickly!

This game was made in Unity, unlike my previous projects you may find on this site. I'm aiming to become more proficient in both, so expect my next project (a 3D exploration platformer) to also be in Unity! My favorite part of developing Relative Evil was creating a framework to fade sprites, UI Text, and UI Images on a strictly scripted schedule. Here I used it to show messages between each new scenario, allowing some of the elements to linger slightly longer for dramatic effect. I'll definitely be using the "fadeable" class I developed in other Unity games!

The art was also quite fun to create for this game. It was done entirely in Aseprite. I first created a perfect version of each sprite and then erased parts of the edges by hand different ways in different frames to give an illusion of lively movement. In combination with moving elements such as the eyes of victims and the wheel rod of the train cars this enhanced the game's style quite a bit without becoming unmanageable for a solo dev.

The music and sound FX for Relative Evil were produced entirely by Chris "Groovetone" Habeeb-Louks. He recorded himself playing trumpet and a variety of percussion instruments to achieve the unique jazzy feel of the game. Chris also produced the music for my previous game relation❤ships.

Story Trigger

"Story Trigger" was my submission to the Shacknews Jam: The Third, which had the theme "_____ with Guns". It's a short narrative experience framed like a D&D scenario where the player character somehow has a gun, inevitably messing up the dungeon master's plans quite a lot! I'll try not to spoil much but I urge you to check it out before reading on.

The game was made in UE4 using the FPS starter content. This time around I only made minimal adjustments to gameplay in favor of crafting a complete story. I began with an in-world screen that would display text and options similar to the terminal windows these sorts of games were first made on, and from there it made sense to construct a movie theatre environment for the player to move around in. The player interacts with the story by aiming at and shooting the option they wish to select.

Story Trigger centers around an unnamed character that either does not remember or does not think of their own past. The town merchant and nearby king both seem familiar with you, with the latter distinctly implying that you have saved the kingdom before. The main difference this time is that you, the player, have a gun. Nobody else in the world has ever heard of such a thing and many assume it is magical in nature. Unless told beforehand most would not even recognize it as a weapon. The result is that you are completely overpowered in your interactions with other people. What will you do when you always have the option to use unrivaled deadly force?

Back to the real world now, this is my favorite creation thus far. I've always been more gameplay and mechanics focused in game jams, for obvious reasons. With only a few days to make a game I tend towards finding something quick and satisfying to play, then polishing that with any remaining time. Crafting a complete story was really my only focus for this one. It was certainly more work than I had initially expected, due in large part to the branching narrative I was trying to achieve. For every decision I wanted the player to be able to make I also wanted some acknowledgement later on in the story, causing many seemingly simple interactions to turn into a mess of conditionals behind the scenes. The end result felt incredibly satisfying to me though, especially for the reactions of players as they experienced different parts of my story.

Another reason this game felt much more complete to me was the music by Melliflox. The main theme is quiet and relaxing, but transitions to a darker and glitchy version when the player shoots a character. I can't talk too much about the other tracks for fear of spoilers, but they contributed a ton to the vibe I was going for in my story and several players complimented the soundtrack specifically! Playing your game with music for the first time is often when it clicks and feels like a real thing you made, at least for me. I hope you try out the game, and please feel free to leave a comment or shoot me an email with your thoughts!

Dizzy Dreadnoughts

"Dizzy Dreadnoughts" was my submission to the 2 Button Jam. The core requirement of this jam was that the game must only accept two inputs. You can check out the game with the link below, or read on for some more info on how it was made!

Like my last game jam I used Unreal Engine 4 to make Dizzy Dreadnoughts. All pixel art animations were created in Aseprite and imported to UE4, where I sliced them into Paper2D sprites and set those up in Flipbook. To create the grid of tiles I simply aligned flipbook actors with the appropriate sprites in a grid formation. Every sprite was 32x32 to ensure proper pixel density and to allow for the tight control scheme.

The music was originally created by Joshua McLean (who was running the jam) and was available to all participants. I used one of his songs as-is and remixed the other two with Audacity to make my gameplay loop music. All other sound effects were generated using BFXR.

I learned a ton about pixel art animation and making 2D games in Unreal Engine. Please check out the game above and some screenshots below!

relation❤ships

"relation❤ships" was my submission to the 2019 Winter ue4jam. The theme of the jam was "All's fair in love and war".

The game features a heart-shaped spaceship that can shoot enemy heart-ships to destroy them, or shoot a special projectile to "bond" with them instead. Once bonded the heart-ship will roam around you and attempt to protect you from other enemy ships. You can form a new bond at any time, but watch out for your ex!

I had a blast making this game. Please check it out!

https://ortsac.itch.io/relation-ships

Lan War 35

Twice a year, the IU Gaming club holds a Lan War. STC (my department) sets up a lounge space nearby the main LAN hall. The "STC ARCADE" is aimed to be a nice short break from the intense PC gaming going on.

This time we iterated on the arcade emulator machines, adding a stacked monitor for a much better title screen. We also featured a new 3D printer, some Halo Xbox action, and old horror movies playing on the large-screen TV.

Below is a gallery of images from the event, as well as a poster and wallpaper I designed!

As a bonus, here are the static HTML pages I made to serve as title screens for the arcade machines. View in full-screen for the intended effect:

• Devil Daggers
• Darkstalkers 3
• Super Ghouls and Ghosts
• Luigi's Mansion
• PAC-MAN Championship Edition
• Typing of the Dead

PowerShell - Setting Default Wallpaper

Setting the default wallpaper in Windows 10 using PowerShell seems pretty straightforward at first, but there are a few roadblocks to look out for.

Say you manage a large collection of machines, and need to set different wallpapers based on location, department, or even monitor size? Sure you could use GPO, setting different wallpapers for different OUs, but what if you want different wallpapers on machines in the same OU? In my experience, you can achieve much more granular control using PowerShell.

For instance, the following helper function will return true if the machine's wallpaper is "wide", which we define as having a width that is 2.2 or more times the height.

Detecting Wide-Screen Monitors

function wide_screen? {
    $vid_con = (Get-WmiObject -Class Win32_VideoController)
    $screen_info = $vid_con.VideoModeDescription -split "[^0-9]+"
    $screen_width, $screen_height = $screen_info | Select-Object -First 2
    $screen_ratio = $screen_width / $screen_height
    return $screen_ratio -ge 2.2
}

In my own collection machines have names containing their department and location info, and we save all that data in environment variables. Using these variables we determine exactly which wallpaper path to use. I say path because Windows 10 is tricky with the default wallpaper. If the monitor is a non-standard (1080p) resolution, then good old img0.jpg is not the default wallpaper. Instead an image most closely matching the resolution of the monitor in C:\Windows\Web\4k\Wallpaper\Windows will be used.

To ensure your custom wallpaper displays well on all monitors, you should generate versions of it at these named resolutions:

1. img0_768x1024.jpg
2. img0_768x1366.jpg
3. img0_1024x768.jpg
4. img0_1200x1920.jpg
5. img0_1366x768.jpg
6. img0_1600x2560.jpg
7. img0_2160x3840.jpg
8. img0_2560x1600.jpg
9. img0_3840x2160.jpg

Then place those in a folder called 4k alongside your 1080p img0.jpg. The path to this collection of wallpapers (hopefully on a server!) is what we'll give to the following function:

Setting the wallpaper

function set_wallpaper($new_wallpaper_path) {
    $sysdata = 'C:\ProgramData\Microsoft\Windows\SystemData'
    $old_wallpaper = 'C:\Windows\Web\Wallpaper\Windows\img0.jpg'
    $old_4k = 'C:\Windows\Web\4k\Wallpaper\Windows'

    $new_wallpaper = "$new_wallpaper_path\img0.jpg"
    $new_4k = "$new_wallpaper_path\4k"

    if ((Get-FileHash $new_wallpaper).hash -ne (Get-FileHash $old_wallpaper).hash) {
        "`n  Removing old wallpaper..."
        get_ownership $sysdata
        make_old $sysdata
        make_old $old_wallpaper
        make_old $old_4k

        "`n  Setting wallpaper to $new_wallpaper..."
        Copy-Item $new_wallpaper $old_wallpaper -Force
        if (Test-Path $new_4k) { robocopy $new_4k $old_4k /E /XO /R:3 }
        "`n  Done!"
    } else {
        "`n  $new_wallpaper is already set as our wallpaper"
    }
}

So what is this doing? Let's break it down.

First off, I save variables for various system paths. Some of these we only use once, but saving them to a variable helps keep the code shorter and more readable.

The if statement checks to see if the current 1080p wallpaper is the same file as the new one we are trying to set, using hash. If the hashes match we go to the else statement and simply log that nothing was changed.

If the hashes don't match, we must be setting a new wallpaper. Here many encounter another roadblock in the form of SystemData. Systemdata, located at C:\ProgramData\Microsoft\Windows\SystemData, contains a cached version of the current wallpaper. This cached version is used on the lockscreen of the machine, and if you set a new wallpaper without also clearing SystemData, you'll have the old wallpaper on the lockscreen still!

To clear out SystemData I first call a helper to take ownership of it and grant full permissions for Administrators.

Get Ownership

function get_ownership($dir_path) {
    $dir_owner = (Get-Item $dir_path).GetAccessControl().Owner
    if (!($dir_owner -like "*Administrators")) { takeown /f $dir_path /a /r /d y }
    icacls $dir_path /q /t /c /grant 'Administrators:(OI)(CI)F'
    "`n  Granted rights on $dir_path"
}

Once that's taken care of it's simply a matter of renaming the old sysdata and wallpaper files to make way for the new ones. These 'backups' will only be as old as the last time you changed the wallpaper though, so it's a good idea to save the default Windows wallpapers before you set it to a custom one in the first place!

The regex used in my -replace statement is simply placing _old at the end of the file name while retaining the file extension after. It's a neat trick!

Save Old Version

function make_old($path_in) {
    if ((Get-Item $path_in) -is [System.IO.DirectoryInfo]) {
        $new_path = "$($path_in)_old"
        if (!(Test-Path $new_path)) { New-Item $new_path -type directory }
        Move-Item -Path "$path_in\*" -Destination $new_path -Force
    } else {
        $new_path = $path_in -replace '\.(...)$', '_old.$1'
        Move-Item -Path $path_in -Destination $new_path -Force
    }
}

I hope you found this article useful. If you encounter any problems with the code above or if it helped make your life a little easier, feel free to reach out!

Vectra City / Video Vortex

Vectra City is a class based deck-building game for two players. It's set in a neo-noir world where the shattered sun is perpetually setting on the horizon, constantly shifting colors.

I was a co-founder of the game along with Mitch Ryckman. Mitch was the head designer of game mechanics and balance, while I provided game design ideas and all the graphic design work needed to attract publishers.

In August 2018 we took our work to GenCon, with playtesting sessions and a publisher "speed-dating" event lined up. In preparation for this we commissioned an original piece by the extremely talented Ed Mattinian, which I used in our sell sheet and several other promotional materials.

Here's some of my graphic design work for Vectra City:

Note: the character art in these is all placeholder, except for our commissioned piece.

GenCon was a massive success! We got tons of helpful info from playtesters, but more importantly we struck a very generous publishing deal with Mondo Games. The game was released as Video Vortex in Q1 2020! Official BGG page here.

Lan War 34

Twice a year, the IU Gaming club holds a Lan War. The past few times, my department has sponsored the event by providing technical assistance, 3D-printed trophies for the tournaments, and by being in charge of the lounge near the main hall.

Our goal with the lounge is to provide a space where gamers tired of sitting at their own machine in the crowded main hall can come to relax, or try some novel play experience. This latest Lan War I think we achieved this exceedingly well. The theme was an arcade from the 80's, complete with classic games such as Teenage Mutant Ninja Turtles and Joust, a modern version of PacMan, and a newer arcade FPS called Devil Daggers.

The other main experience involved two immersive driving simulator setups, with triple curved monitors around the user and a steering wheel/pedal combination to control. The game of choice for this experience was WreckFest, a racing game featuring cockpit-view and realistic car damage.

We also sponsored a Hearthstone Fireside gathering for the second time, allowing any nearby players to try a new gamemode and unlock the warlock hero Nemsy Necrofizzle. Additionally, Mitch and I had a playtest of Vectra City set up.

To top it all off, one of my coworkers edited together 80's movies with iconic 80's commercials and music videos between them. The STC Arcade was a huge success, with people coming all night to check out the games, try for a high-score, or relax and watch a classic movie. Below are some pictures from the event space, as well as some graphics I designed to advertise it.

P423 Compilers

My very last class at Indiana University was P423 - Compilers. It was a project course, with the goal of the semester being the construction of a Racket compiler that supported functions.

We broke this difficult task into easier steps, each one translating an intermediary language to something a bit closer to the assembly. Along the way we implemented conditionals, vectors, static and dynamic typed data, and finally user-defined functions.

Our final project was to build on our compiler in a novel or useful way. I chose to focus on optimization of the input code, aiming to produce simpler assembly programs in less time. Check out my final presentation.

Phi Kappa Chi

Phi Kappa Chi was a project I worked on as part of Hoosier Games. It was to be an RPG where you, the protagonist Scotty, are a new pledge for the fraternity PKC. Things go awry when your frat is banned from the campus, and you must conquer the other fraternities to fix things.

The game was heavily inspired by LISA, and would have featured black comedy as a central storytelling element. I served as the project's only developer and was teaching myself Unity as we went.

Ultimately, I think we made good progress for a single semester. The biggest triumph for me was creating a classic RPG battle system from scratch. You can find a video of an older demo in action here and I have some slightly newer screenshots below.

B355 Robotics

I took a basic course on robotics in 2015. We built simple machines with metal and plastic parts, including a microcontroller, gears, motors, servos, and a variety of sensors. We programmed the bots with RobotC.

Labs built up to two main tasks: maze traversal and inverse kinematics PID control. Below you can find a gallery of images I took while building our maze traversal bot. The IK bot can be seen in action here.

P317 Code Entropy

I took an Information Theory class back in 2013. Here's a synopsis of my final project.

Entropy is a measure of disorder. In hard sciences, it can be quantified to describe the number of possible states a system can be in. In information theory, entropy can be quantified in a similar way as the amount of information that can be acquired by observing the state of a system. A static system will have entropy zero; an un-weighted coin flip will usually have entropy around 1 bit.

Finding the entropy of natural language has certainly been done before. Any string of words may be treated as a list of characters. In turn, the probability of each character can be measured and the entropy can be found based on Shannon's equation. However, code is not natural language. We may type it character by character, but not every character is considered equal when the computer interprets our program. The largest difference is that words using alpha-numeric characters may be grouped together. As a whole, any word and most punctuation in programming languages can be referred to as a "token". A token is essentially any object that can be interpreted by the computer. It is the smallest possible unit that is significant in code, thus it is the smallest possible unit with which we should measure the entropy in code.

My task became clearer at this point. To find the entropy of a program, I first had to tokenize it and collect a list of all the tokens. Here's the function in charge of making that list:

def tokenize(byte):
    global token
    if byte == ' ' or byte == '\n':
        if token != '':
            tokens.append(token)
        token = ''
    elif byte in string.punctuation:
        if token != '':
            tokens.append(token)
        tokens.append(byte)
        token = ''
    else:
        token += byte

Once I iterated through the entire list, the entropy of the list of tokens could be calculated based on each member's conditional probability. Following is the formula for Shannon Entropy:

def entropy(list):
    entropySum = 0.0
    seen = []
    for x in list:
        if x not in seen:
            probability = list.count(x) / len(list)
            entropySum += probability * log2(probability)
            seen.append(x)
    return -entropySum

Full source code can be found here.

It is interesting to note the varying effects that tokenizing a string can have on its entropy. For instance, if one takes the entropy of a relatively simple program without tokenizing it and compares that to the tokenized entropy, it's likely that the tokenized entropy will be lower. This is because a tokenized string will have less members than one in which every character is considered independent. However, the more complex a program gets, the greater the tokenized entropy will be, eventually far surpassing the un-tokenized entropy. This is due to the number of possible characters being far lesser than the number of possible combinations of those characters. This allows for entropy to follow vocabulary linearly in very long or complex code, whereas normal methods for calculating entropy of a string would follow a more logarithmic pattern as the code grows in complexity.

To compare the entropy of different languages, one should use code that accomplishes the same task. For example, here's the 'reverse string' program in each of the languages I analyzed:

Brainfuck reverse string

,----- ----- [+++++ +++++ > , ----- -----]<[.<]+++++

C++ reverse string

int main() {
    std::string s;
    std::getline(std::cin, s);
    std::reverse(s.begin(), s.end());
    std::cout << s << std::endl;
    return 0;
}

Java reverse string

public static String reverseString(String s) {
    return new StringBuffer(s).reverse().toString();
}

Python reverse string

string[::-1]

Scheme reverse string

(define (string-reverse s)
  (list->string (reverse (string->list s))))

Haskell reverse string

reverse = foldl (flip (:)) []

I chose these languages to represent a broad spectrum of programming languages, but if research is to be taken further it may be wise to increase the scope of the languages analyzed. My general hypothesis followed that the languages could be ordered according to ascending complexity/entropy: Brainfuck, Scheme, Haskell, Python, Java, C++. To test this, I analyzed code from each language across several tasks. I used Rosetta Code as a database to find standardized examples of different tasks in each programming language.

Results

| | Hello World | Reverse String | Bubble Sort | |:--------- | -----------:| --------------:| -----------:| | Brainfuck | 1.85 | 2.05 | 2.59 | | C++ | 4.28 | 4.40 | 5.48 | | Haskell | 2.95 | 3.10 | 4.23 | | Java | 4.50 | 3.76 | 4.80 | | Python | 2.95 | 2.52 | 4.39 | | Scheme | 2.25 | 3.01 | 3.59 |

The results roughly supported my hypothesis, with Brainfuck and Scheme being less complex, C++ and Java being more complex, and Python and Haskell sitting around the middle. I'd be interested to see if this trend would continue when vast amounts of code are analyzed, including standard libraries.

And there you have it, my little foray into Information Theory. It was one of my favorite classes so I hope you found this project interesting!