Truthfully, (and technically) the guys on the rpi forum are correct... there are a few ways to do this... but really you don't want to do any of them. and here is why:
1, you want to create some kind of shim, that sits between the arm chip and the os level, something between the HAL and the hardware. I guess kind of like a hypervisor and emulator rolled into one.
now find an open source hypervisor for x86 (like open stack) look at the amount of code that's produced over a number of years by a team. (in fact not A team but many teams from Redhat, and Amazon, and Rack space (big companies are needed to bankroll this kind of development at any appreciable speed)
then go find an open source emulator that's developed over a number of years by a team. and thing about how when it's just you doing this you probably won't complete this before you die.
if you do a search for raspberry pi bare metal you'll find a bunch of tutorials by cambridge university, in one the guys writting the lectures admits that he spent weeks trying to get the OS to accept keyboard input.
you'll be trying to get your hypervisor shim to accept all inputs, and then pass it through to your windows OS.
if you even get that far it'll be dog slow... (i'll tell you why later)
there is another way that you can do this.
you can take a pre-built OS, like linux.
you can take a pre built hardware emulator like qemu to emulate a different chipset
you can take an API emulator like wine and emulate the windows APIs. and run your EXE.
that's a hell of a lot of layers. your application, if it works at all will once again be "dog slow"
Intel Galileo vs. Raspberry Pi | Mouser
read there, whilst you think that the rpi is fast cause it's 1GHz, that's just the amount of instructions it can process, but it's a RISC chip, so with it's reduced instruction set instead of complex it doesn't go as much per clock cycle. it's compatible with a really old pentium 2.
basically this thing meets the "base" requirements that windows XP first came with. but (aside from windows XP not being supported any more) windows XP didn't support .net, the frame work was an addon optional install. by the time you get to framework 3 or 4 those hardware requirements were much much bigger than the pentium 2 that XP's first minimum specs were. (in fact XP would seem slow on a pentium 4 at 2 Ghz today. - you'd be trying to run with a quarter of the resources (if you managed to get windows running on your "shim" layer, and IF that "shim" layer was incredibly resource efficient...
or you've got a slow bit of hardware trying to run a full OS, trying to emulate hardware and trying to emulate APIs on top of that. if you could even get that working (I don't even know if wine exists for ARM - so you might need to cross compile and debug that too!) that's a huge stack of software for such a small board to run.
realistically, like I told you before, you have only two options here.
1, buy an x86 compatible board (the galileo isn't the only one.) - and I'm pretty sure that there are other options for video out other than the pre-made shields the DSI interface should support bigger TFTs.
unless you value your time at tenths of cents per hour. (or you have fortune 500 style resources to throw at this)
Quantum View (FULL HD) 10.1" Windows Tablet with Microsoft® Office 365Quantum
just get that, it's only two hundred bucks, it's got a great battery life, it nativly runs intel chip (quadcore atom) with 2 GB of RAM. a 32GB hard drive, full size USB ports, touchscreen, 10" screen, comes with screen protector case and keyboard included.
(seriously if you're doing this in work time then you already spent that much in time just asking questions here!)
2, re-write the application.
(I struggle to see how you're going to do this for a price of less than two hundred bucks that you could just buy a full integrated surface clone for, -that would just run your application.)
do you have the source for the .exe application?
if you do, then you can do two things.
either, get the application re-written in a non OS and non specific platform code (by which I mean Java) (if you have the source you might get this done cheaper, since your coder can look at the source to find out a lot of the logic.
or (assuming it is .net and does nothing too fancy) compile it on linux using the mono libraries (that run .net code) and the run it as a native linux binary.
(you'll want to cross compile for ARM. if you hope to compile on an x86 desktop)
or you can use qemu to emulate ARM hardware on your X86 desktop, and run the raspberry pi disk image, and compile inside rasbian on your desktop then just copy the binary to your pi...
do you understand how difficult software development can be?
just how deep this deep end that you're trying to dive into is?
and how cheap the simple solution to just run your windows app in windows is?
