I didn't want to see Nyscersul's thread derailed too much.

Obviously, having some sort of plugin installer/manager would make the lives of some players easier.

Part of what I envision an installer doing is pulling a list of available plugins from a single source (e.g. VOUPR) and then downloading from that source. It could possibly also support installing from user-provided files. Once installed, at a minimum it should allow for deleting plugins, and also a rudimentary (en|dis)able function which could be accomplished by either renaming main.lua or simply moving the directory (e.g. <VO>/plugins/disabled/<my_disabled_plugin>.

Another feature to consider would be support for plugin profiles (e.g. Dev, PirateGuild, TradeGuildImInfiltrating).

The big question is: how do we accomplish this across all platforms?

Trying to figure out what language to use for the least amount of variability between platforms quickly turned into a headache for me and I lost interest.

Java might work for this purpose using https://www.codenameone.com/ to convert the code for use on iOS and Android.

Another option might be https://coronalabs.com/

So far as the potential for using Anyx, it is restricted in it's flexibility by being forced to work within the VO sandbox. As such, it is not ideal for distribution or management of any large, multi-file plugins. Even single-file plugins required special treatment. Further, unless drazed wants to release it, the server code is not available, even if you happen to have a copy of the client lying around.

A feature I'd want is to have it track the integrity of the plugin files. Sometimes I modify plugins, so at minimum I want it to be able to produce a list of which plugins have been altered, and to warn me before updating a plugin that I've modified in case I need to re-do those changes to the new version. Bonus points if it keeps pristine archives of the plugins so that it can produce diffs of the changes automatically.

Does anyone have any thoughts on what language and GUI library might be best suited to this project? If it were possible to use VO's implementation of IUP, I'd seriously consider writing something in Lua with small loaders in native languages for each platform.

Also, does anyone know of any possible pitfalls with Android or iOS for reading/writing files belonging to other applications?

A little further research into iOS seems to indicate that because of the sandbox model they use for apps, having an installer/manager installed on the device just wouldn't be feasible. However, since plugins otherwise have to be installed via iTunes(?) or another file manager, this could probably be worked around by simulating a VO install directory on a Mac and then just working with the files/directories before requiring a sync/copy action be performed to the mobile device.

In addition to the above discussion, it may be possible to go a step further and introduce in-game management via plugin, though the methods of accomplishing this either toe or cross the line of responsible plugin development. I would prefer to see in-game management supported at an official level, than try to hack something in.

EDIT:
One semi-invasive way that could possibly be used to handle this without getting tricky in the client would be to rename the main.lua of all plugins as they're being installed (e.g. <pluginname>.main.lua), and then creating a new main.lua that might consist of something like

--------------------------------------------------
if (not (DisabledPlugins and DisabledPlugins.<pluginname>)) then dofile("<pluginname>.main.lua") end
-------------------------------------------------

The in-game manager could then be named to load before everything else and initialize DisabledPlugins based on stored values.

This way, even if the manager gets lost or removed at some point, the plugin shouldn't just break.

The installer should have the ability to only do this as an opt-in, and should be able to reset the plugins to their original state.

On a whim, I've been reading about programming Java. I'm not sure if it's just because of its nature as object-oriented or because of the way it has implemented OO Programming, but this language seems to be unnessarily obtuse.

So, I'm still reading about Java and probably going to attempt to make at least a command-line-based tool as a starting point. With a properly designed interface it should be fairly trivial to implement a GUI on top of it later.

Actions:
get-available-plugin-list
search-plugins
install-plugin
enable-plugin
disable-plugin
remove-plugin
list-installed-plugins
verify-plugins

create-profile
copy-profile
switch-profile
remove-profile
list-profiles
backup-system-notes
restore-system-notes
copy-system-notes

count me in as a tester