So yeah, this happened. Basically, I’ve been working on this for the past three days, instead of doing the sketches and finishing the flat colors I said I would. I still haven’t finished sketching all the concepts I want to introduce to my galleries, but I ended up running into some bad feelings due to a particular sketch and that made me wanna not draw for that day, which led to me going back to coding.
I missed coding… painful as it is, it can still be really fun when things work. And here they did work, which is great, and now this application is FULLY FUNCTIONAL.
If people show interest, I’ll try to tidy things up and make everything neat with more functionalities, but this is the minimum viable product or whatever the pros call it.

What is it? Well, in short this is a little application that allows you to tag a submission by clicking the tags on the screen instead of typing them out. It also automatically merges tags together, such as “anthro” and “bunny” into “anthro_bunny”, and creates aliases for them automatically, such as “lagomorph” and “rabbit” when “bunny” is added.
In this way you really only have to click “anthro” and “bunny” and the tags you will get are: “anthro”, “bunny”, “rabbit”, “lagomorph”, “anthro_bunny”, “anthro_rabbit”, “anthro_lagomorph”.
The only catch is that you need to set those fusions or aliases yourself through a json file, since I could never hope to know what tags are relevant for each given individual and I wanted to make the application very plastic. The way you do it is by telling it what to do through the json ONCE, and when that is ready, you can just open the application and click tags, then either export it as a .txt file (ctrl+E) or copy it (ctrl+C). The tags are ready to be pasted on whatever site you’re posting to (optimized for SoFurry, Weasyl and InkBunny).
Again, the set-up only has to be done one time, and after that it’s super easy to use.

I will now explain how it works, mostly, with the help of some pictures linked throughout the text.

First, the basic interface: <Interface 01>
I divided the screen into four parts, one for the “Entries”, one for your entire pool of tags in the json, one for your “Sets” and an empty one where I was going to add the option to modify tags, Sets and so on, on the go, without having to touch the json.
Each of these tabs can be scrolled through up and down with the mouse scroll wheel as this print poorly depicts: <Interface 02>

The Entries are “Containers” that receive tags, and they are where the tag merging happens. It was done like this mostly to make characters, so you can enter each character as a separate Entry. Tags inside an Entry such as “anthro” and “bunny” will merge into “anthro_bunny” when you click Update (note that the original tags are maintained after “anthro_bunny” is added). If there is another Entry, which is supposed to be another character, such as “feral” “bear”, it will make “feral bear” WITHOUT making “feral_bunny” or “anthro_bear”.
The “Individual Entries” tab holds all the entries, and like all tabs, it scrolls up and down.

Clicking individual tags on the other two tabs will either create a new Entry, which will be automatically selected OR add tags to the selected Entry. To de-select an entry, just click at the “Individual Entries” tab name. To select an Entry, click on the Entry’s name.
Entries are named after what created them, so either the tag’s group or the set that was clicked.
Clicking tags inside an Entry will REMOVE the tags from that individual entry, while double-clicking an Entry’s NAME with the RIGHT CLICK will DELETE that Entry.
The creation of an Entry with the used tags is shown here: <Interface 03>
Tags become automatically highlighted when in use by one or more entries. Tags in an Entry scroll side-to-side when the mouse is over that Entry, like any other Container.

The “Tag Groups” tab holds all the different tag groups, which are just broad groups of tags, all spawned from the json. This tab will not be modified on the go, but it is where you can click individual tags and add them to an entry. The groups are Containers which scroll side-to-side, while the entire tab scrolls up and down. This way if a group has too many tags, you can scroll through them to see more.
The different tag groups are up to the user and you can set them up however you want in the json. I THINK the order follows the same order from the json, but I didn’t take too many measures to force that, so who knows. But if you want to keep them organized in a particular way, you can give that a try. IT DOES NOT HAVE TO BE IN ALPHABETICAL ORDER.

The “Your Sets” tab functions like the others in scrolling, but it has an extra functionality, which is browsing Sets. What are Sets? They are like tag presets which you might use frequently. Because I draw my characters a lot, I might want to add our tags often, and sets are a quick way to do that. When clicked, ALL OF THE TAGS in a set are added to an Entry.
Again, if there is no Entry selected, it will create a NEW Entry, with the SAME NAME from the Set that was clicked, as shown here: <Interface 04>
When you want to add another character, be sure to de-select the Entry by clicking the “Individual Entries” tab. The Entry’s header will go from green to white, showing that it’s not selected anymore, allowing you to spawn a new Entry from another Set. In this way you can add multiple characters easily, as shown here <Interface 05>
If there are any missing tags, you can always add them later, as shown here <Interface 06>

Sets also have SubSets, which is where the extra tab functionality comes. When clicking a Set’s title, you will go inside it if it has SubSets, and the new sets displayed are those SubSets.
So you can imagine the “Your Sets” tab as displaying all Sets as SubSets of the whole application. And when you click a set, you will show that Set’s SubSets instead. Clicking the header of the tab will restore the parent Set, or return to the layer above.
Set navigation can be seen here, with the parent set at first: <Interface 09>
Then the collection of SubSets the clicked Set has. Note that the name of the tab changed to represent the Set that was clicked: <Interface 10>

To merge the tags, make sure to click Update, or press (ctrl+U) I HAVE NO IDEA HOW IT WORKS ON OTHER OPERATIONAL SYSTEMS. In hindsight I should have probably called the Update automatically whenever Copy or Export are clicked, but I forgot, so make sure to click Update before clicking those.
The Updating can be shown through these two pictures:
<Interface 06>
<Interface 07>
When you’re done, feel free to hit Export (ctrl+E) or Copy (ctrl+C). Export will create a tags.txt file, which is saved in the same location as the json (inside the “Yiff Tag Helper_Data” folder, for Windows, at least). This file has ALL the tags including the aliases, which is where “bunny” becomes “bunny”, “rabbit”, “lagomorph”.
Hitting Copy will do the same for the tags, but they copy to the clipboard instead of to a file, so it’s just like Export, but without a file creation. Copy is quicker, since you don’t have to open a file, but Export is safer, since you won’t lose the tags if you accidentally hit PrintScreen or something, which is why I gave both options.
The result is shown here, from the same sequence as the images linked above: <Interface 08>
Tags that are duplicate are automatically removed.

I WILL NOW EXPLAIN HOW THE JSON WORKS AND HOW TO SET UP YOUR OWN TAGS:

Again, even though I made this for my own use, I wanted to make it available for other people as well, and because I can’t decide on the tags other people will use, I built the whole thing around being able to easily modify the tags inside whenever you need, whoever you are. You don’t even need a code editor program or anything, NotePad will do.

First the Tags, of course: <Json 01>
Here is where you enter ALL the tags you wanna be able to see while running the application. If you don’t know how jsons work… don’t worry, just do like I always did and make sure to copy what’s already in there, only modifying the fields such as name and so on.
To make a new one, all you have to do is copy that entire segment, from the curly brackets to the comma (THE COMMA IS IMPORTANT), just follow the structure that is already in there and you should be fine.
“tagClass” is obsolete, you can ignore it or type anything you want. I was gonna use that to divide things first but gave up on it for a more generalistic set-up.
“group” is important, as it is what displays on the “Tag Groups” tab I showed above. You can enter any names you want there and the program handles it for you, the same name results in the same group, of course.
“name” is the tag name, which is also very important, as similar names will count as the same tags. I have no idea what happens if you add different tags with the same name… if my code prediction senses are right it should just take the first one and ignore the others (I told it to loop through the collection of tags until it finds a matching name), but WHO KNOWS… best avoid it.
“aliases” are part of where the magic of this program happens! That is where all the different synonyms will show up and stuff, where “bunny” also adds “lagomorph” and “rabbit”. You can do WHATEVER YOU WANT with those, they are only used in the very end of the process, when exporting, so you can type anything in there. ALL OF THE ALIASES OF A TAG ARE ALSO GENERATED IF THAT TAG IS PRESENT ANYWHERE. But aliases don’t show up inside the application, to avoid clutter.
For tags that can either merge or split, make sure that the stuff they become are also on the list of tags, though, or that function is ignored. More on that later, when I talk about “Instructions”.

Now the Sets: <Json 02>
Sets are a lot more complicated to think about, since they can nest within one another… BUT… instead of making that painful to deal with in the json, I decided to go for a much more easily understandable approach and made it name-based.
Because of that, the “name” of a Set is VERY important, since it tells the program what Sets are SubSets of it.
That leads to the next point, “parent”, which sets a parent for the Set. All Sets with the same parent will be nested into it while the application is running, and you can browse that as discussed before.
“tags” are all the tags contained by that set, of course, and this can get a little bit complicated, since these three interact together, so I’ll explain more now:
A root parent Set should ONLY have the most BASIC of tags (like the name of a character, for instance, or things that never change). Subsets can add more tags which COMPLEMENT the previous ones, and when a SubSet is clicked, all tags from the parent Set are added as well. In the application, SubSets already DISPLAY the tags of the parent, but in the json, they don’t need to. Remember to keep the tags inside the brackets, between quotations and separated by commas.
So the main set could be something like just the tag “little_jimmy” or whatever, with SubSets containing things such as “adult” or “cub”, which themselves can split into having tags like “male” and “female”, depending on what you want to do.
So you find the version of the character you want (adult woman little Jimmy), and click that, adding all the tags “little_jimmy”, “adult”, “female”.
This is of course up to you, since tags can be easily removed after being added, but the functionality is designed around this usage.

And finally, the Instructions: <Json 03>
Instructions are well… instructions on which tags should become what when in the presence of other tags. This could be through two ways: Division or Combination.
Division can be used for fetish implications, such as when a given fetish also implies other tags automatically, such as “lipstick_on_penis”. You can tell it to also add “lipstick” and “penis” when that tag is encountered.
Combination is what takes tags such as “anthro” and “bunny” and makes “anthro_bunny”. This is something I noticed was bothering me while I was tagging my submissions, so the entire application is kinda built around this and the aliases.
Speaking of aliases, the tags the Instructions are handling should ALL be in the json already, in the list of tags. Aliases are automatically applied, since a given fusion should have that alias already. I thought about making them on the go, but that brought some problems.
Okay, now how to use Instructions?
“name” is kinda irrelevant, I ended up not doing anything with that. I guess be careful because having the same name will probably cause only the first one to be used, since that’s how I coded it.
“tags” are the set of all tags that need to be together for that Combination to happen. Like the picture shows, it is things like “anthro” and “bunny”, and all of those tags must be present within the SAME ENTRY for it to do anything. Make sure to have them inside those brackets, separated by commas and between quotations, as all other names.
“combination” is the resulting tag, what will be added to that Entry when Update is clicked. Again, this combination tag NEEDS to exist in the json already, or else it is ignored. Because it is one of the tags already in the list, it is assumed that you have already defined all its aliases, which are used in the end. So if the result is “anthro_bunny”, you only have to name THAT ONE, and leave “anthro_rabbit” and “anthro_lagomorph” as its ALIASES, up there in the TAG SECTION, and the program will handle the rest for you. Don’t make extra Instructions for aliases.
“tag” is a target tag for division, it’s pretty much the opposite of a combination, you name something like “lipstick_on_penis” and expect it to automatically split into “lipstick” and “penis”.
“divisions”, as said above would be the result of a tag division, so you can do some basic fetish implications like that, if you want, since “lipstick_on_penis” already implies the presence of “lipstick” and “penis”, without having to add them as aliases. The advantage of this is that EACH OF THESE TAGS can have THEIR OWN ALIASES, without you having to worry about any of them. You set the aliases for “lipstick_on_penis” as “lipstick_on_cock” or “blowjob_marks” or whatever that would be… and then “lipstick” could have “lipstick_mark” or “make-up” or whatever, and “penis” could have “dick”, “cock” and so on. Just like “tags”, keep them inside the brackets, between quotations and separated by commas.

Again, the json file can be found in the folder “Yiff Tag Helper_Data” inside the version folder. The version folder being where you click to open the application. It is called “save.json” or just “save” if your file browser hides extensions.
After setting up the json with that in mind, all you have to do is use the program. You can go back to add more tags or sets or instructions whenever you feel like.
I wanted to add the functionality to do all that INSIDE the application, without needing to manually edit the json, but I wanted to go back to drawing and it was taking me too long.

In the future I might add a bunch of other stuff, such as making the UI better, giving options for configurations (font size, UI display, etc.), as well as a search function, but this is what I have to offer for now. Let me know if you’d like me to improve on this.
Again, the application as I’m making it available already has a few tags, but it is very much not sufficient and you HAVE to add your own, or else it can’t really be used. Hope yall enjoy this because it took me some hard work.
If you’re interested in me coding more and doing more things, let me know. There are some things I wanna do, but I have this feeling that people would appreciate drawings more. ppsssstt I can make lewd games tho

DOWNLOAD LINK:
Link to the Unity build: https://www.dropbox.com/s/ikqun59ku.....v0007.rar?dl=0
Oh god why did it take like hours just to type this stuff?