Adding new wheels in Forza, means adding a registry key with data about your device, namely how many axes, buttons and hat switches it has.
Since Creator's update, MS has changed the way devices are defined in registry, and once the meaning of values were decoded, adding new wheels
or gamepads seems very simple.

The keys of supported wheels can be found here:
\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\GameInput\Devices\

Each of the keys represent one device. Key naming consists of VendorID + ProductID + Usage Page + Usage
So if we would want to add another wheel to supported devices list, we would have to determine the hardwareID
of the wheel, by going to device manager, expanding Human Interface Devices, right clicking on your device,
choosing Details and then selecting Hardware Ids from the drop-down menu.
You will be presented with the string that is formatted in following way:
USB\VID_xxxx&PID_xxxx&REV_xxxx


So for example, if you look at Hardware ID of Logitech Driving Force Pro, it looks like this:
USB\VID_046D&PID_C298&REV_1106

Where chars following VID_ are VendorID and chars following PID_ are ProductID (revision is not important).
Knowing VendorID and ProductID we can construct the name of the registry key for our device. In this case
it would be:

046DC29800010004 (VendorID + ProductID + Usage Page + Usage)

You don't have to worry about Usage Page and Usage, as it is the same for all devices that are recognized as game controllers,
where 0001 means generic Desktop and 0004 means Joystick.

If you examine existing keys, you will find, that all of them contain the definition for device,
either RacingWheel, GamePad or ArcadeStick.

There is also Description value, which basically is the name of your device, but it doesn't seem to have any effect on Forza games so far.
Sometimes there is a UINavigation value, which as the name implies, defines your device as a UI controller in all UWP apps.

Then there is a subkey Labels which allows you to assign a name for each button and hat switch position. Presumably this will be
read by games to make the UI interface more friendly by substituting generic labels with the ones defined here.

Here I will examine only the most important part: the definition for your controller which will allow you to use it in UWP apps. The other data
is either self-explanatory or follows the same rules that will be described here.

The easiest way to get started is to export an existing Key and edit it in a text editor of your choice.
Lets take as an example value for Logitech G27 (046DC24F00010004)

"RacingWheel"=hex:02,05,00,85,02,85,03,85,04,04,0a,05,0a,04,8b,00,cb,00,eb,00,\
  ab,00,0a,07,0a,14,0a,16,0a,06,0a,13,0a,15,0a,0f,0a,10,0a,12,0a,11,08,08,08,\
  08,08,08,0a,0e,0a,08,0a,09,0a,0a,0a,0b,0a,0c,0a,0d,0a,00,00,00

The name of the value indicates the type of device that is reported to UWP apps. This means that you can theoretically report your wheel
as gamepad or vice versa with the expected consequences. In this case Logitech G27 is defined as "RacingWheel"

Lets look at the actual data now. It seems that first byte for all device definitions is 02.
If next byte is 05, it defines a symmetrical two way axis (for example: -1 0 1) where 0 is the default position and -1 and 1 are both extremes.
This type is used for steering and gamepad sticks.
The axis type is always followed by an index of axis on your controller. For most wheels it is the (X) axis, but since everything here
is zero indexed, then first axis should be written as 0 (similarly 2nd axis would be 01, 3rd would be 02 etc.)

For wheels we need only one symmetrical axis definition (for gamepads we need more as there are several sticks with left/right, up/down functionality).
So right now definition for our wheel looks like this:
02,05,00

Let's add definitions for pedals:
For pedals we should use byte value 85, which indicates assymetrical one way axis (for example: 0 1) where 0 is the default position and 1 is the value
when pedal is fully pressed. Actual indices of axes for pedals vary from one device to another, and you should experiment with values, until you get it right.
The application I provided makes this much easier, as you do not have to launch forza each time, to test changes.
The order of axes for steering wheels seems to be the following:

Steering axis | Accelerator axis | Decelerator axis | Clutch axis | Handbrake axis |

Only the first three are mandatory for wheels, while the latter two can be ommited. Now ommiting stuff can be a little tricky in these definitions,
since you need to leave a sort of placeholder where data would otherwise be.
In our Logitech G27 example we see the following:

   Steering axis | Accelerator axis | Decelerator axis | Clutch axis | Handbrake axis
02,   05,00,         85,02,        85,03,       85,04,       04


As you see we have steering and three pedals defined, but we do not have handbrake defined, which is indicated by value 04 that takes place
of the definition of handbrake axis. If we would want to define handbrake, we would have to replace 04 with the actual definition that is
two bytes long. So assuming handbrake is on 6th axis our definition would look like this:


   Steering axis | Accelerator axis | Decelerator axis | Clutch axis | Handbrake axis
02,   05,00,         85,02,        85,03,       85,04,      85,05

And similarly if we would want to define a wheel with only gas and brake pedals, we would do it like this:

   Steering axis | Accelerator axis | Decelerator axis | Clutch axis | Handbrake axis
02,   05,00,         85,02,        85,03,       04,               04

This concludes the axis definition part and following Logitech G27 we now have the following string:
02,05,00,85,02,85,03,85,04,04

Immediately after handbrake axis definition (or placeholder byte for it), two buttons are defined, namely PreviousGear and NextGear.
Button definitions are always indicated by byte 0a which is followed by button index (which again is zero based, so button 1 should be written
as 0, button 2 as 1 etc.)

So lets look at Logitech G27 example:
0a,05,0a,04

As you can probably guess, this means that button 6 on your wheel is assigned to PreviousGear and button 5 on your wheel is assigned to NextGear.
So, now our string looks like this:
02,05,00,85,02,85,03,85,04,04,0a,05,0a,04

After these two definitions, there is a definition for hat switch or better known as DPad.
Luckily the DPad definition is always the same (presumably each pair of bytes defines one of four positions):
8b,00,cb,00,eb,00,ab,00

However if your device does not support dpad, you should not include this definition, but susbtitute it with placeholder bytes.
Similarly to how definition for axis was two times the length of placeholder, here too we need to replace definition for each position with
a placeholder byte. For all buttons, the placeholder byte is 08.
So compare the two definitions:
1) With dpad:
02,05,00,85,02,85,03,85,04,04,0a,05,0a,04,8b,00,cb,00,eb,00,ab,00

2) Without dpad:
02,05,00,85,02,85,03,85,04,04,0a,05,0a,04,08,08,08,08

After DPad definition or placeholder bytes, comes definitions or placeholder bytes for 16 buttons.
Lets look at the G27 example:
0a,07,0a,14,0a,16,0a,06,0a,13,0a,15,0a,0f,0a,10,0a,12,0a,11,08,08,08,08,08,08

Decoded it looks like this:
Button in-game                Button on your device

Button1             Button6
Button2             Button19
Button3                  Button21
Button4             Button5
button5             Button18
Button6                  Button20
Button7             Button14
Button8                  Button15
Button9             Button17
Button10          Button16
Button11               None
Button12          None
Button13                         None
Button14          None
Button15               None
Button16          None

As you see, 10 buttons are defined, so that leaves 6 buttons undefined, which are indicated by placeholder bytes 08.

After 16 buttons, we define our H-Shifter (and if we do not have one, we add placeholder bytes 08).
The definition have the following order
Reverse Gear
Forward Gear 1
Forward Gear 2
Forward Gear 3
Forward Gear 4
Forward Gear 5
Forward Gear 6
Forward Gear 7

So the following string:
0a,0e,0a,08,0a,09,0a,0a,0a,0b,0a,0c,0a,0d,0a,00

Would translate to:
Reverse Gear      Button13
Forward Gear 1      Button7
Forward Gear 2      Button8
Forward Gear 3      Button9
Forward Gear 4      button10
Forward Gear 5      Button11
Forward Gear 6      Button12
Forward Gear 7      Button1

Finally, to make your definition complete you should add two more bytes. For the time being their meaning is unknown, but
it seems that either 00, 00 or 01, C2 will get your wheel recognized correctly.

If you have followed this guide, you should have a working wheel in Forza now.
I will release a tool later which configures your wheel automatically for you, but for now you can experiment.
Please use the application I have written from this link: http://www.mediafire.com/file/5dsx2u1co8u6bbz/Controller+Test+Tool_1.0.6.0_Test.zip
It uses the same API that Forza games use, and the input reported in that API will be the same that will be reported in Forza games.
One more thing though, since it is an UWP app, you can't launch it as regular exe, and since it is not running through MS store, you have to
install it manually. For that you first have to add certificate:
Right double click on Controller Test Tool_1.0.6.0_x64.cer and choose Install Certificate , choose Local Machine and Place All Certificates in the following Store,
Click browse, select Trusted Root Certification Authorities and click next.
Afterwards double click on Controller Test Tool_1.0.6.0_x64.appxbundle and install the app.

IF you do not feel comfortable adding certificates you can still test your definitions in Forza game, but remember that you have to restart Forza
or replug your controller after each edit you make.

Have fun!