My quest for a comfortable and natural dual stick flight controls began when I came across a Logitech Extreme 3D Pro in the clearance section of a Best Buy for 20 USD. Already owning a Thrustmaster T-Flight Hotas X which I had purchased for 40$ years before, a 60$ dual stick set-up seemed to good to pass up. After plugging everything in and spending the good part of an afternoon researching and trying the many configurations the community uses I noticed a trend in designs. Most configurations are built around trying to give the pilot control of every aspect of the ship as possible. The most common is to use the right stick to control the vehicles position, and the left stick to control rotation. These images seem to be the most common configs for Dual Stick (A least for the Axis's themselves) As I flew around in arena commander I noticed that I could not come to learn these schemes. Instead I naturally move both sticks in the direction that I wanted to rotate. As if they both controlled the direction of rotation. More interestingly I discovered that I often pointed the sticks independently of each other. Frequently pointing them in contrast when i wanted my ship to rotate at a slower rate, or pointing them in the same direction when I wanted it to rotate faster. My current theory is framed in a static ship aiming exercise. Imagine that while manipulating the right stick to follow and track and enemies general large movement, the left stick, while having the same axis controls of the right, would be used to adjust for their minute changes in speed and direction. One stick to follow their large momentum and one stick to follow their small evasions. I believe this system of control may make aiming easier and more accurate. A Poor MS Paint demonstrating the idea. Star Citizen in its current state of 3.5.1 does not allow multiple controls to be bound to a single action. And attempts to replicate this theory in Elite Dangerous are unsuccessful for the same reason. So i turned to external sources. My research of trying to turn the inputs of two joysticks into one net joystick control lead me to a Reddit post by user PMaxxGaming, I which he attempts, unsuccessfully, a similar idea using an Custom XML from SCJMapper. This idea did not work because the most recently updated stick would override all control and not to add the two directions together. https://www.reddit.com/r/starcitizen/comments/81ardy/does_anyone_have_a_workaround_for_binding_more/ And with this information my quest for a Dual Axis flight control ended. While this system is not perfect due to its loss of accurate control of Vertical and Horizontal strafe, having to shift your hand to control throttle, and possible sharp learning curve, I would very much like to attempt it. Unable to find alot of information about this idea i've simply called it Dual Axis flight. If anyone has any ideas what this Control scheme is called or a manner of achieving it I would love to know. After the helpful replies below, a system that fully accomplishes this was able to be found. By using Joystick Gremlin and User Plugin provided by user Marcsand2 a Dual Axis/Stick system can be created that allows the option to adjust the strength of each Joystick. I control 80% of the rotation with my right stick, and 20% with the left. High Res Example https://giant.gfycat.com/LinedBlandBalloonfish.webm ------------------------------------------- ------------------------------------------- ------------------------------------------- ------------------------------------------- ------------------------------------------- ------------------------------------------- The conclusion of my findings are yet to be seen, with the small exception that I am now a pirate killing machine and a god among men in the PU. The compromise of using the hats for stafe , and thus less control, is an easy trade for the increased performance when tracking a moving target. While this control model may not take over all Dual Stick pilots, I can see this being the most optimal set up for Turret Operators. In turn I encourage all Dual Stick pilots to try this configuration and hope that no one bumps into you, for their fate is sealed in the blood of their ignorance. ------------------------------------------- ------------------------------------------- ------------------------------------------- ------------------------------------------- ------------------------------------------- ------------------------------------------- The User Plugin by Marcsand2 (I also have a modified version that has Z Axis control, but it is to large to post. Message me if you need it.) import math import gremlin from gremlin.user_plugin import * mode = ModeVariable("Mode", "Mode in which to use these settings") input_1 = PhysicalInputVariable( "Right x-axis", "First physical input axis", [gremlin.common.InputType.JoystickAxis] ) input_2 = PhysicalInputVariable( "Right y-axis", "Second physical input axis", [gremlin.common.InputType.JoystickAxis] ) input_3 = PhysicalInputVariable( "Left x-axis", "Third physical input axis", [gremlin.common.InputType.JoystickAxis] ) input_4 = PhysicalInputVariable( "Left y-axis", "Fourth physical input axis", [gremlin.common.InputType.JoystickAxis] ) ratio = FloatVariable( "Ratio Right / Left", "Size of the outer deadzone", 0.8, 0.0, 1.0 ) output_1 = VirtualInputVariable( "Output x-axis", "Virtual combined output axis", [gremlin.common.InputType.JoystickAxis] ) output_2 = VirtualInputVariable( "Output y-axis", "Virtual combined output axis", [gremlin.common.InputType.JoystickAxis] ) # Decorators dec_1 = input_1.create_decorator(mode.value) dec_2 = input_2.create_decorator(mode.value) dec_3 = input_3.create_decorator(mode.value) dec_4 = input_4.create_decorator(mode.value) class Calculate: def __init__(self, rx, ry, lx, ly): self.rx = rx self.ry = ry self.lx = lx self.ly = ly def x(self): return ratio.value * self.rx + (1 - ratio.value) * self.lx def y(self): return ratio.value * self.ry + (1 - ratio.value) * self.ly def __str__(self): return "[{:.2f}, {:.2f}, {:.2f}, {:.2f}]".format(self.rx, self.ry, self.lx, self.ly) # Last axis value storage g_last_values = Calculate(0.0, 0.0, 0.0, 0.0) # Updates the vJoy device def update_vjoy(vjoy): device = vjoy[output_1.value["device_id"]] device.axis(output_1.value["input_id"]).value = g_last_values.x() device = vjoy[output_2.value["device_id"]] device.axis(output_2.value["input_id"]).value = g_last_values.y() # Callbacks for the individual axes @dec_1.axis(input_1.input_id) def axis1(event, vjoy): global g_last_values g_last_values.rx = event.value update_vjoy(vjoy) @dec_2.axis(input_2.input_id) def axis2(event, vjoy): global g_last_values g_last_values.ry = event.value update_vjoy(vjoy) @dec_3.axis(input_3.input_id) def axis3(event, vjoy): global g_last_values g_last_values.lx = event.value update_vjoy(vjoy) @dec_4.axis(input_4.input_id) def axis4(event, vjoy): global g_last_values g_last_values.ly = event.value update_vjoy(vjoy)