I suggest you ...

Greatly increase support for GPU programming in C#

-Support GPU programming in C# -both general and graphical- on at least equal level with C++. On every Microsoft platform.
-Design the future versions (or successor) of DirectX with C# in mind.

1,583 votes
Vote
Sign in
Check!
(thinking…)
Reset
or sign in with
  • facebook
  • google
    Password icon
    I agree to the terms of service
    Signed in as (Sign out)
    You have left! (?) (thinking…)
    ColeCole shared this idea  ·   ·  Flag idea as inappropriate…  ·  Admin →

    23 comments

    Sign in
    Check!
    (thinking…)
    Reset
    or sign in with
    • facebook
    • google
      Password icon
      I agree to the terms of service
      Signed in as (Sign out)
      Submitting...
      • msedimsedi commented  ·   ·  Flag as inappropriate

        I absolutely agree, but it should be kept in mind, that i should be a generic solution. OpenCL is not such a solution. There must be something that scales to every CPU and/or GPU. Having only the things for nvidia does not help at all. You need upwards and downwards solutions depending on the system you have. Creating adapted code for each GPU in nvidia to get the best performance is not generic. For hardcore/high-performance developers yes, but not for the broad mass.

      • Daniel EgloffDaniel Egloff commented  ·   ·  Flag as inappropriate

        Alea GPU version 3 currently in development will have fully automated memory management to communicate with GPU

      • Daniel EgloffDaniel Egloff commented  ·   ·  Flag as inappropriate

        With Alea GPU we offer a complete professional solution for GPU programming with .NET languages, including debugging, profiling and a growing collection of GPU primitives and libraries that integrate with our stack. It is cross platform and self contained hence does not need any further tools or compilers installed (e.g. CudaFy requires the NVIDIA CUDA C/C++ compiler installed) - fee community version - check it out here http://www.quantalea.com/

      • AkAk commented  ·   ·  Flag as inappropriate

        Or just move to F# - http://fsharp.org/use/gpu/

        No need for Microsoft to be the first mover here - if you want to make a framework for doing this or contribute to the C#/F# frameworks listed on the above page your more than welcome. More contributors to open source frameworks to do this would be great - IMO C# and F# already support features that make it possible to compile/translate .NET code into GPU code (expressions, quotations)

      • AnonymousAnonymous commented  ·   ·  Flag as inappropriate

        This can be done in managed way and without corrupting debuging expirience.
        Look at Cudafy:
        https://cudafy.codeplex.com/

        They support debugging via emulation, all GPu cards and CPU (OpenCL) and NVidia (CUDA).

        So basically you would write functions as usual but decorated with some attribute:

        [Kernel]
        static void SomeFunc(CLThread thread, int someParam)
        {
        //normal C# code
        }

      • Ben Voigt [Visual C++ MVP]Ben Voigt [Visual C++ MVP] commented  ·   ·  Flag as inappropriate

        .NET is highly intertwined with a runtime, dynamic memory allocation, garbage collection. The experience on the GPU wouldn't be the same at all. You're going to have to write GPGPU code as C-with-classes anyway... wouldn't better integration of C++AMP into C# be as good as trying to create a C#-AMP?

      • Miha MarkicMiha Markic commented  ·   ·  Flag as inappropriate

        Perhaps a good option is to use C++ AMP stuff (http://msdn.microsoft.com/en-us/library/hh265137.aspx) in a separate library and create a managed wrapper around it that communicates the minimum possible data. BTW I've made C# framework for doing GPU a while back ago. It was like you were programming in C# using a custom C# library and the generated code would be compiled for the GPGPU during compilation time. It was working but later hadn't have time to push it forward.

      • Gary BirchGary Birch commented  ·   ·  Flag as inappropriate

        The capability of writing GPGPU code for various types of calculations should be available to all .Net languages i.e. VB, F#, etc... not just C++ programmers. I would also like to see layers of abstraction added to the stack to allow other capablilties with data types other than integers and float types. In particular allowing the use of Strings in arrays along with the implementation of their related functions would provide extremely useful capabilities for development in all languages.

      • AnonAnon commented  ·   ·  Flag as inappropriate

        Use SharpDX, I have been using it for almost 18 months and it is great, it gets updated frequently and the support / performance is great, if you actually look at Win8 development (although SharpDX can be used with XP / 7 depending on DX version you want to support) MS do in fact recommend using it.

        It is also opensource and free, maybe MS could help with advertising. Oh and SharpDX is also available via NuGet

      • Gavin WilliamsGavin Williams commented  ·   ·  Flag as inappropriate

        Both SlimDX and SharpDX provide the ability to use DirectX from C#, they are both excellent wrappers. I noticed SharpDX was mentioned at Build. But Microsoft needs to accept that people want to program in C# and have full access to DirectX. So either provide an ongoing managed wrapper, that is maintained with DirectX or provide some support for these independent projects. They do need support. And why not encourage people to use those wrappers ? Instead of telling people that C++ is how games should be made on Windows now, because a lot of people don't want to program in C++.

      • KenKen commented  ·   ·  Flag as inappropriate

        I believe WPF has GPU support for the GUI.
        What else is needed?

      • TomTom commented  ·   ·  Flag as inappropriate

        Please give us DirectX in C# on Windows 8, Metro and on Windows Phone 7.8, 8.0!

      • Tom SpilmanTom Spilman commented  ·   ·  Flag as inappropriate

        Anyone that wants DirectX in C# should just go grab SharpDX (http://www.sharpdx.org). It is an excellently thin C# wrapper around DirectX.

        If you want XNA in Metro then go look at MonoGame (http://monogame.codeplex.com) which current has Metro support working in a development branch.

        While it would be nice for MS to provide an official DirectX binding for C#... it isn't necessary.

      ← Previous 1

      Feedback and Knowledge Base