Well, Android/x86 for now.  I've been plugging away at getting D running on Android/x86 and got all of the druntime modules' unit tests and 37 of 50 phobos modules' unit tests to pass. I had to hack dmd into producing something like packed TLS for ELF, my patch is online here:

http://164.138.25.188/dmd/packed_tls_for_elf.patch

I simply turned off all TLS flags for ELF and spliced in the el_picvar patch from OS X to call ___tls_get_addr.  Somebody who knows dmd better than me should verify to make sure this is right.

I've also put online preliminary pulls for druntime and phobos:

https://github.com/D-Programming-Language/druntime/pull/784
https://github.com/D-Programming-Language/phobos/pull/2150

Now that a significant chunk of D is working on Android/x86, I'm looking for others to pitch in.  We really need to get D on mobile, and Android/x86 is an ideal place to start.  Dan Olson has done some nice work getting D on iOS using ldc, I'm sure he could use help too:

http://forum.dlang.org/thread/m2txc2kqxv.fsf@comcast.net
http://forum.dlang.org/thread/m2d2h15ao3.fsf@comcast.net

Stuff remaining to be done:

1. Fix all phobos unit tests.  Those who know the failing modules better would be best equipped to get them to work.

2. I tried creating an Android app, ie an apk, which is really just a shared library called from the Dalvik JVM, as opposed to the standalone executables I've been running from the Android command line so far.  The apk enters the D code and then segfaults in the new TLS support, I'll debug that next.

3. Use ldc/gdc to build for Android/ARM.

4. Start translating various headers on Android so they can be called from D, ie EGL, OpenGL ES, sensors, etc.

5. Integrate the D compilers into the existing Makefile-based build system of the Android NDK.  Right now, I extract the necessary compiler and linker commands and run them by hand when necessary.

All you need to get going is to download the latest Android NDK (http://developer.android.com/tools/sdk/ndk/index.html) and run Android/x86 (http://www.android-x86.org/, I recommend the 4.3 build) in a VM.  I'll put up some basic setup and build instructions if someone is interested.

On Thursday, 8 May 2014 at 16:16:22 UTC, Joakim wrote:
> Well, Android/x86 for now.  I've been plugging away at getting D running on Android/x86 and got all of the druntime modules' unit tests and 37 of 50 phobos modules' unit tests to pass. I had to hack dmd into producing something like packed TLS for ELF, my patch is online here:
>
> http://164.138.25.188/dmd/packed_tls_for_elf.patch
>
> I simply turned off all TLS flags for ELF and spliced in the el_picvar patch from OS X to call ___tls_get_addr.  Somebody who knows dmd better than me should verify to make sure this is right.
>
> I've also put online preliminary pulls for druntime and phobos:
>
> https://github.com/D-Programming-Language/druntime/pull/784
> https://github.com/D-Programming-Language/phobos/pull/2150
>
> Now that a significant chunk of D is working on Android/x86, I'm looking for others to pitch in.  We really need to get D on mobile, and Android/x86 is an ideal place to start.  Dan Olson has done some nice work getting D on iOS using ldc, I'm sure he could use help too:
>
> http://forum.dlang.org/thread/m2txc2kqxv.fsf@comcast.net
> http://forum.dlang.org/thread/m2d2h15ao3.fsf@comcast.net
>
> Stuff remaining to be done:
>
> 1. Fix all phobos unit tests.  Those who know the failing modules better would be best equipped to get them to work.
>
> 2. I tried creating an Android app, ie an apk, which is really just a shared library called from the Dalvik JVM, as opposed to the standalone executables I've been running from the Android command line so far.  The apk enters the D code and then segfaults in the new TLS support, I'll debug that next.
>
> 3. Use ldc/gdc to build for Android/ARM.
>
> 4. Start translating various headers on Android so they can be called from D, ie EGL, OpenGL ES, sensors, etc.
>
> 5. Integrate the D compilers into the existing Makefile-based build system of the Android NDK.  Right now, I extract the necessary compiler and linker commands and run them by hand when necessary.
>
> All you need to get going is to download the latest Android NDK (http://developer.android.com/tools/sdk/ndk/index.html) and run Android/x86 (http://www.android-x86.org/, I recommend the 4.3 build) in a VM.  I'll put up some basic setup and build instructions if someone is interested.

interesting.

Awesome. I appreciate this work.

On 2014-05-08 12:16 PM, Joakim wrote:
> All you need to get going is to download the latest Android NDK
> (http://developer.android.com/tools/sdk/ndk/index.html) and run
> Android/x86 (http://www.android-x86.org/, I recommend the 4.3 build) in
> a VM.  I'll put up some basic setup and build instructions if someone is
> interested.

Thanks for this, it's more than necessary and I believe no time will have been wasted.

On Thursday, 8 May 2014 at 16:16:22 UTC, Joakim wrote:
> Well, Android/x86 for now.  I've been plugging away at getting D running on Android/x86 and got all of the druntime modules' unit tests and 37 of 50 phobos modules' unit tests to pass. I had to hack dmd into producing something like packed TLS for ELF, my patch is online here:
>
> http://164.138.25.188/dmd/packed_tls_for_elf.patch
>
> I simply turned off all TLS flags for ELF and spliced in the el_picvar patch from OS X to call ___tls_get_addr.  Somebody who knows dmd better than me should verify to make sure this is right.
>
> I've also put online preliminary pulls for druntime and phobos:
>
> https://github.com/D-Programming-Language/druntime/pull/784
> https://github.com/D-Programming-Language/phobos/pull/2150
>
> Now that a significant chunk of D is working on Android/x86, I'm looking for others to pitch in.  We really need to get D on mobile, and Android/x86 is an ideal place to start.  Dan Olson has done some nice work getting D on iOS using ldc, I'm sure he could use help too:
>
> http://forum.dlang.org/thread/m2txc2kqxv.fsf@comcast.net
> http://forum.dlang.org/thread/m2d2h15ao3.fsf@comcast.net
>
> Stuff remaining to be done:
>
> 1. Fix all phobos unit tests.  Those who know the failing modules better would be best equipped to get them to work.
>
> 2. I tried creating an Android app, ie an apk, which is really just a shared library called from the Dalvik JVM, as opposed to the standalone executables I've been running from the Android command line so far.  The apk enters the D code and then segfaults in the new TLS support, I'll debug that next.
>
> 3. Use ldc/gdc to build for Android/ARM.
>
> 4. Start translating various headers on Android so they can be called from D, ie EGL, OpenGL ES, sensors, etc.
>
> 5. Integrate the D compilers into the existing Makefile-based build system of the Android NDK.  Right now, I extract the necessary compiler and linker commands and run them by hand when necessary.
>
> All you need to get going is to download the latest Android NDK (http://developer.android.com/tools/sdk/ndk/index.html) and run Android/x86 (http://www.android-x86.org/, I recommend the 4.3 build) in a VM.  I'll put up some basic setup and build instructions if someone is interested.

I can't tell you how much I appreciate this! It's wonderful. All the stuff I'm working on will have to go on smart phones and tablets sooner or later. People do ask for it, because everything is an "app" these days.

Much as I appreciate all the efforts to improve D as a language (GC, library etc.), if we can't get into the mobile market, D won't take off. People think "app". "What do you think?" - "Think? Is there an app for that?"

On Thursday, 8 May 2014 at 16:16:22 UTC, Joakim wrote:

Great to hear! Much appreciated.

Le 09/05/2014 15:22, Chris a écrit :
> On Thursday, 8 May 2014 at 16:16:22 UTC, Joakim wrote:
>> Well, Android/x86 for now.  I've been plugging away at getting D
>> running on Android/x86 and got all of the druntime modules' unit tests
>> and 37 of 50 phobos modules' unit tests to pass. I had to hack dmd
>> into producing something like packed TLS for ELF, my patch is online
>> here:
>>
>> http://164.138.25.188/dmd/packed_tls_for_elf.patch
>>
>> I simply turned off all TLS flags for ELF and spliced in the el_picvar
>> patch from OS X to call ___tls_get_addr.  Somebody who knows dmd
>> better than me should verify to make sure this is right.
>>
>> I've also put online preliminary pulls for druntime and phobos:
>>
>> https://github.com/D-Programming-Language/druntime/pull/784
>> https://github.com/D-Programming-Language/phobos/pull/2150
>>
>> Now that a significant chunk of D is working on Android/x86, I'm
>> looking for others to pitch in.  We really need to get D on mobile,
>> and Android/x86 is an ideal place to start.  Dan Olson has done some
>> nice work getting D on iOS using ldc, I'm sure he could use help too:
>>
>> http://forum.dlang.org/thread/m2txc2kqxv.fsf@comcast.net
>> http://forum.dlang.org/thread/m2d2h15ao3.fsf@comcast.net
>>
>> Stuff remaining to be done:
>>
>> 1. Fix all phobos unit tests.  Those who know the failing modules
>> better would be best equipped to get them to work.
>>
>> 2. I tried creating an Android app, ie an apk, which is really just a
>> shared library called from the Dalvik JVM, as opposed to the
>> standalone executables I've been running from the Android command line
>> so far.  The apk enters the D code and then segfaults in the new TLS
>> support, I'll debug that next.
>>
>> 3. Use ldc/gdc to build for Android/ARM.
>>
>> 4. Start translating various headers on Android so they can be called
>> from D, ie EGL, OpenGL ES, sensors, etc.
>>
>> 5. Integrate the D compilers into the existing Makefile-based build
>> system of the Android NDK.  Right now, I extract the necessary
>> compiler and linker commands and run them by hand when necessary.
>>
>> All you need to get going is to download the latest Android NDK
>> (http://developer.android.com/tools/sdk/ndk/index.html) and run
>> Android/x86 (http://www.android-x86.org/, I recommend the 4.3 build)
>> in a VM.  I'll put up some basic setup and build instructions if
>> someone is interested.
>
> I can't tell you how much I appreciate this! It's wonderful. All the
> stuff I'm working on will have to go on smart phones and tablets sooner
> or later. People do ask for it, because everything is an "app" these days.
>
> Much as I appreciate all the efforts to improve D as a language (GC,
> library etc.), if we can't get into the mobile market, D won't take off.
> People think "app". "What do you think?" - "Think? Is there an app for
> that?"
+1

On Thursday, 8 May 2014 at 16:16:22 UTC, Joakim wrote:
> All you need to get going is to download the latest Android NDK (http://developer.android.com/tools/sdk/ndk/index.html) and run Android/x86 (http://www.android-x86.org/, I recommend the 4.3 build) in a VM.  I'll put up some basic setup and build instructions if someone is interested.

Please do. I'd recommend adding it to the Core Development section on the wiki so that it doesn't get lost.

http://wiki.dlang.org/

Thanks!

I've been reading on Emscripten and LDC and how they would be nice together, and came across this nice little library:
http://www.leaningtech.com/duetto/examples/

It's a C++ server/client framework that compiles to JS through clang => LLVM bytecode => ASM.js.

I'd like to point out that asm.js is a very fast subset of the javascript language that allows almost native speeds (3x slowdown vs C only) which enables games to be run in the browser without external dependencies.

This had me thinking of forking the Emscripten project in order to support the druntime / phobos library & give it access to the browser DOM interface, as to allow javascript web applications to be written fully in D (to produce interfaces like openUI5 and more).

This would have multiple advantages:
- Suitable for huge front-end development frameworks using safe typing and contractual programming
- Opens the door to petaFLOPS of distributed CPU power based simply on website visitation without affecting user experience
- Allows Javascript proprietary code to be harder to de-obfuscate or reverse engineer
- FAST Browser-based database engines and full runtime capabilities can be developed (and added as browser extensions for persistence) to be actively used by the server with a simple interface

And most of all, it simplifies web development.

I'm not going to instantly call for a project to be started, but I'd love to hear some why do's and why don'ts b/c I don't like to rely on my point of view alone.

wrong button ;)