Observation

[kryton9]

Charles, I am very excited to read what you wrote. I think not only for Oxygen, but for any language and even for developing any major project it would be nice to know that it will be viable for some time to come and be able to run on multiple platforms. As Eros pointed out in the thinBasic forums, he has so many lines of code for thinBasic, it is not possible(desirable) to redo all of that work to change to another foundation.

I am happy that in your research that you feel that this could be an even easier foundation for you than x86!

[Charles Pegge]

I think this will give us the best opportunity to go cross platform, and also tap into the power of the multi core GPUs.

The online compiler demo shows what it looks like. Human readable after a fashion. And it is encouraging that the instruction set is quite small.

http://llvm.org/demo/index.cgi

Nvidia only announced their intention to use LLVM on the 16th Dec. We don't know how long it will take to produce the product. ATI have also made an announcement abut using LLVM and will doubless be following in haste.

Charles

[kryton9]

Will you use LLVM from the their site or register with NVidia to use theirs?

[kryton9]

http://www.winsupersite.com/blog/supersite-blog-39/windows8/winrt-replacing-win32-140605

But after conferring with others and studying Microsoft's documentation, I can make the following general statement: WinRT (the new Windows Run Time) is not a replacement for Silverlight or .NET, it's a replacement for Win32. And that means that it's the new native runtime for Windows, and not a managed code layer that sits higher on the stack.

[kryton9]

I went and looked at WinRT and here is a listing for Graphics. I don't see anything for OpenGL or WGL!!!!
http://msdn.microsoft.com/en-us/library/windows/apps/br205756

I don't know what is going on now?
No OpenGL for Metro Apps:
http://social.msdn.microsoft.com/Forums/en-US/winappswithcsharp/thread/a861db02-dce8-4f61-9969-b8a7a7cd55c7

[Petr Schreiber]

Kent,

with Windows 8, we could look at it as 2 different platforms:

• Win8 for x86/x64 (normal apps + metro apps)
• Win8 for ARM(metro apps)

WinRT
In the future, if it catches, it might become full replacement. For now, I would rely on info directly from MS.

I checked out the official, work-in-progress documentation, it looks very .NET style to me
http://msdn.microsoft.com/en-us/library/windows/apps/hh464942%28v=VS.85%29.aspx

Interesting note is this:

The Windows Runtime packs core functionality for building Metro style apps into a small API surface

So it seems it is primarly targeted at Metro apps, which are from what we saw not designed for desktop use in first place.

Here Microsoft hosted blog:
http://blogs.microsoft.co.il/blogs/sasha/archive/2011/09/15/winrt-and-net-in-windows-8.aspx

To summarize, WinRT does not replace .NET, nor does it compete with .NET – and the same applies to Win32.

I don't think Metro style apps are something to be used as platform for writing AutoCAD or AAA games, it has different purpose (a bit more of gadget style) so I would not be surprised to not see OpenGL there.
On Windows phones you also have just Direct3D like coding for long time, although it is not problem of different CPU architecture (judging from OpenGL ES running happily on Android devices).

Windows 8 for x86/x64
Regarding OpenGL on Windows 8 Preview, Eros tested thinBASIC and TBGL scripts there, not a single issue observed.


Petr

[kryton9]

Thanks Petr, it is a little bit assuring... but, since WinRT is not a layer above win32 but its equivalent, it means the win32 is gone sooner or later.
Just like now, I can run 32 or 64 bit versions of programs like Blender. I always choose the 64 bit version if I have a choice.

I have been using my android phone and tablet now and all I can say is everyone can use those interfaces from Babies to very old people, the size of the tablet more so than the phone.

Anyways, once people have a choice of a fullscreen, no windows, no menus, touch interface or the same old windows they have seen with mouse and keyboard, the choice will be solid for
the new technology.

The win32 will be dead and removed you will see in a couple of years, it just has to be for Windows to survive.

The next big question is will Microsoft make DirectX run on ARM and other hardware platforms, like OpenGL does? If so, that could mean the death of OpenGL.
John Carmack says already DirectX is better than OpenGL now. It is the trend setter and not the laggard like it was. He said he will still use OpenGL because of
all the code he has into it and all his tools.

[efgee]

As a high-level assembler, LLVM catches my interest! Looking at the instruction set, I believe it would be quite simple for Oxygen to emit LLVM instructions, in fact a lot simpler than it was to produce x86 stuff.

If portability is needed:
Don't have any experience in Java but what about Jasmin.

Jasmin is an assembler for the Java Virtual Machine. It takes ASCII descriptions of Java classes, written in a simple assembler-like syntax using the Java Virtual Machine instruction set. It converts them into binary Java class files, suitable for loading by a Java runtime system.
Maybe someone else has more input on Java.

Another solution would be to target tcc. (here is the repository)
Tcc creates executables for Win/Linux/Unix/BSD/PE/ELF/x86/x64/ARM.
This way only the conversion from Basic to C is needed.
(There is also libtcc so no c file needs to be created, all happens in memory)

[Charles Pegge]

Thanks Frank, I'm looking at the logistics of providing various emitters. There are at leat 2 levels. One being high-level assemblers like CIL,JVM, LVMM and the other being compiler-level C or C++.

In an ideal scheme, one would one would simply tap into the code production line at two points and reformat the outputs.

Unlike the others LVMM is not a stack machine. It had me puzzled for a few days but I can now see a way to convert oxygen's stack-based expressions.

Example:

a=b+c*d

left bracket push. right bracket pop

a=b+(c*d)

load b
push b
load c
mul d
pop-add

in LLVMish

%1=%c * %d
%a=%a+%1


Charles