I would like to develop (or find, if one is already in development) a framework with support for accelerated graphics and sound built on a system flexible enough to compile to the following:

• native ppc/x86/x86_64/arm binaries or a language which compiles to them
• javascript
• actionscript bytecode or a language which compiles to it (actionscript 3, haxe)
• optionally java

I imagine, for example, creating an API where I can open windows and make OpenGL-like calls and the framework maps this in a relatively efficient manner to either WebGL with a canvas object, 3d graphics in Flash, OpenGL ES 2 with EGL, or desktop OpenGL in an X11, Windows, or Cocoa window.

I have so far looked into these avenues:

• Building the game library in haXe
  • Pros:
    • Targets exist for php, javascript, actionscript bytecode, c++
    • High level, object oriented language
  • Cons:
    • No support for finally{} blocks or destructors, making resource cleanup difficult
    • C++ target does not allow room for producing highly optimized libraries -- the foreign function interface requires all primitive types be boxed in a wrapper object, as if writing bindings for a scripting language; these feel unideal for real-time graphics and audio, especially exporting low-level functions.
    • Doesn't seem quite yet mature
• Using the C preprocessor to create a translator, writing programs entirely with macros
  • Pros:
    • CPP is widespread and simple to use
  • Cons:
    • This is an arduous task and probably the wrong tool for the job
    • CPP implementations differ widely in support for features (e.g. xcode cpp has no variadic macros despite claiming C99 compliance)
    • There is little-to-no room for optimization in this route
• Using llvm's support for multiple backends to target c/c++ to web languages
  • Pros:
    • Can code in c/c++
    • LLVM is a very mature highly optimizing compiler performing e.g. global inlining
    • Targets exist for actionscript (alchemy) and javascript (emscripten)
  • Cons:
    • Actionscript target is closed source, unmaintained, and buggy.
    • Javascript targets do not use features of HTML5 for appropriate optimization (e.g. linear memory with typed arrays) and are immature
    • An LLVM target must convert from low-level bytecode, so high-level constructs are lost and bloated unreadable code is created from translating individual instructions, which may be more difficult for an unprepared JIT to optimize. "jump" instructions cause problems for languages with no "goto" statements.
• Using libclang to write a translator from C/C++ to web languages
  • Pros:
    • A beautiful parsing library providing easy access to the code structure
    • Can code in C/C++
    • Has sponsored developer effort from Apple
  • Cons:
    • Incomplete; current feature set targets IDEs. Basic operators are unexposed and must be manually parsed from the returned AST element to be identified.
    • Translating code prior to compilation may forgo optimizations assumed in c/c++ such as inlining.
• Creating new code generators for clang to translate into web languages
  • Pros:
    • Can code in C/C++ as libclang
  • Cons:
    • There is no API; code structure is unstable
    • A much larger job than using libclang; the innards of clang are complex
• Building the game library in Common Lisp
  • Pros:
    • Flexible, ancient, well-developed language
    • Extensive introspection should ease writing translators
    • Translators exist for at least javascript
  • Cons:
    • Unfamiliar language
    • No standardized library functions, widely varying implementations

Which of these avenues should I pursue? Do you know of any others, or any systems that might be useful?

Does a general project like this exist somewhere already?

Thank you for any input.