It's happening.

Studio Pro for free ;)
http://blogs.msdn.com/b/visualstudio/archive/2014/11/12/visual-studio-2015-preview-visual-studio-community-2013-visual-studio-2013-update-4-and-more.aspx

.NET Open Source
http://blogs.msdn.com/b/dotnet/archive/2014/11/12/net-core-is-open-source.aspx

.NET have a good and open sourced GC, so maybe it's possible to get something useful from it?

.Net does have a pretty damn good GC. It is both a moving garbage
collector (improves locality, reduces heap fragmentation and
allows for memory allocation to be a single pointer operation)
and a generational garbage collector (reduces garbage collection
cost by leveraging heuristic that most collected objects are
usually very young). I believe their server GC is even concurrent
to avoid long stop the world pauses.

The problem is I'm not sure how much of those principles can be
applied to D. I can see moving objects being problematic given
that D supports unions. Another thing to consider is that .Net's
GC is the results of many man years of full time work on a single
platform, while D is mostly done by volunteers in their spare
time for many platforms. It would probably require a lot of work
to port, unless you're volunteering yourself for that work;)

On a related note, I've wondered for a long time why D's GC isn't
generational and why there's all this discussion on making it
concurrent and none on making it generational. It seems to me
that making it generational is simpler than making it concurrent
and provides a net win in overall performance while concurrent
only provides a win for real time systems that can't afford long
GC cycles.

On Friday, 21 November 2014 at 08:02:07 UTC, philippecp wrote:
> The problem is I'm not sure how much of those principles can be
> applied to D. I can see moving objects being problematic given
> that D supports unions.

Unions make up only a small percentage of all objects; a mostly precise GC can be enough. It cannot be fully precise anyway, because of C code (addRoot), and the stack, which is hard to make precise.

> On a related note, I've wondered for a long time why D's GC isn't
> generational and why there's all this discussion on making it
> concurrent and none on making it generational. It seems to me
> that making it generational is simpler than making it concurrent
> and provides a net win in overall performance while concurrent
> only provides a win for real time systems that can't afford long
> GC cycles.

There is some work. For example, Rainer Schuetze presented a precise GC at Dconf, which is a requirement for that. See also this post by deadalnix, who proposes separating the global heap(s) from the thread-local ones:
http://forum.dlang.org/thread/kpgilxyyrrluxpepepcg@forum.dlang.org

On Friday, 21 November 2014 at 08:02:07 UTC, philippecp wrote:
> .Net does have a pretty damn good GC. It is both a moving garbage
> collector (improves locality, reduces heap fragmentation and
> allows for memory allocation to be a single pointer operation)
> and a generational garbage collector (reduces garbage collection
> cost by leveraging heuristic that most collected objects are
> usually very young). I believe their server GC is even concurrent
> to avoid long stop the world pauses.
>
> The problem is I'm not sure how much of those principles can be
> applied to D. I can see moving objects being problematic given
> that D supports unions. Another thing to consider is that .Net's
> GC is the results of many man years of full time work on a single
> platform, while D is mostly done by volunteers in their spare
> time for many platforms. It would probably require a lot of work
> to port, unless you're volunteering yourself for that work;)
>
> ...


The official .NET runs on x86, x64, ARM (including cortex variants), MIPS.

It scales from embedded hardware running with 512KB of flash and 128KB of RAM (http://www.netmf.com/get-started/), all the way up to Azure deployments.

http://www.microsoft.com/net/multiple-platform-support

--
Paulo

On Friday, 21 November 2014 at 12:54:05 UTC, Paulo  Pinto wrote:
> On Friday, 21 November 2014 at 08:02:07 UTC, philippecp wrote:
>> .Net does have a pretty damn good GC. It is both a moving garbage
>> collector (improves locality, reduces heap fragmentation and
>> allows for memory allocation to be a single pointer operation)
>> and a generational garbage collector (reduces garbage collection
>> cost by leveraging heuristic that most collected objects are
>> usually very young). I believe their server GC is even concurrent
>> to avoid long stop the world pauses.
>>
>> The problem is I'm not sure how much of those principles can be
>> applied to D. I can see moving objects being problematic given
>> that D supports unions. Another thing to consider is that .Net's
>> GC is the results of many man years of full time work on a single
>> platform, while D is mostly done by volunteers in their spare
>> time for many platforms. It would probably require a lot of work
>> to port, unless you're volunteering yourself for that work;)
>>
>> ...
>
>
> The official .NET runs on x86, x64, ARM (including cortex variants), MIPS.
>
> It scales from embedded hardware running with 512KB of flash and 128KB of RAM (http://www.netmf.com/get-started/), all the way up to Azure deployments.
>
> http://www.microsoft.com/net/multiple-platform-support
>
> --
> Paulo

I meant operating system, not architecture. At this point it still only runs on Windows based OS.