Another update on the experimental branch! Highlights are: - A much better AOT (ahead-of-time) compiler, now available as a separate command line executable, macrubyc. It can compile some MacRuby sample code. Details at the very end of this message. - IB support is back! Once you install experimental IB can show the classes and their outlets/actions that you defined in your Ruby code, inside Xcode, as previously. It still uses the same command line tool based on Ripper. - More Ruby and Cocoa compatibility. Detailed changes: - AOT compiler: added support for compilation of NSObject, IDs, blocks, dynamic variables, instance variables, cleanup exception handler, global variables, literal symbols & immediates, - RubySpec was updated from upstream. - Fixed a bug in the way we compile literal strings, before the same instance was reused which was bad since strings are mutable. - Implemented END{} blocks. - Fixed a bug in IO.copy_stream, IO#print, implemented IO#initialize_copy. - Fixed lexical constant lookup inside classes defined within a builtin class. - The Ripper C extension is now supported again. It is built and installed as part of the normal build process. First C extension on experimental! - Fixed a bug in the instance variable slot logic where it was only called for T_OBJECT types. - Added a workaround for missing 64-bit informal protocol annotations in BridgeSupport. - Installed a cleanup exception handler in macruby_main(). - Optimized dummy calls to <=>: inside the code base. - Mark thread block locals as used. This fixes a bug where a thread's block was using a local variable right after the method exited. - Implemented the internal rb_rescue() and rb_ensure() APIs. - Implemented ThreadGroup. - Re-implemented return-from-block to use a specialized C++ exception instead of SjLj. This is to make sure ensure blocks are honored, to conform to the Ruby specs. - Force the installation of the static .a library within MacRuby.framework (for AOT compiler). - Fixed the setting of $? post a popen-based expression. - Removed the --compile command line argument from the macruby executable, added the --emit-llvm argument which dumps the LLVM bitcode. This is only for internal use, users should use the new macrubyc executable instead. - Introducing macrubyc, a command line tool interface to the AOT compiler. macrubyc allows you to compile a given Ruby file into a Mach-O object file and/or produce a final executable. Produced Mach-O objects are true object files. They can be used to form a MacRuby executable or you can also use them into your Objective- C project that uses the MacRuby Objective-C API. Produced executables embed all the compiled Ruby code as well as MacRuby, statically. It can be distributed as is and does not depend on anything MacRuby or LLVM at runtime. The Ruby source code is compiled into native machine code (same process as we do at runtime with the JIT compiler), so it's also a good way to obfuscate the source code. The final binary looks like an Objective-C binary (except that it's larger). macrubyc behaves like gcc. An example: $ echo 'p 123' > t1.rb $ echo 'p 456' > t2.rb $ macrubyc -c t1.rb -o t1.o $ macrubyc -c t2.rb -o t2.o $ macrubyc t1.o t2.o -o t $ ./t 123 456 Which can be rewritten in a shorter form: $ macrubyc t1.rb t2.rb -o t $ ./t 123 456 Ruby files are loaded using the link order. You can also provide any .o file during link time. Example: $ cat t.m #import <Foundation/Foundation.h> @interface Foo : NSObject @end @implementation Foo + (void)foo { NSLog(@"foo"); } @end $ gcc -c t.m -o t.o -fobjc-gc $ cat t2.rb Foo.foo $ macrubyc t.o t2.rb -o t $ ./t 2009-07-11 22:04:37.229 t[12964:903] foo Here, we link a Ruby source file with a pure Objective-C source file and it works. macrubyc is still very preliminary but it can compile a few samples that we ship, like DotView or PathDemo (I did not try all of them yet). We will provide an Xcode target to automatize the compilation of a MacRuby Xcode project, but in the meantime you can try the command line. An example for PathDemo: $ cd build/Release/PathDemo.app/Contents/Resources/ $ cat prelude.rb framework 'Cocoa' $ cat main.rb NSApplicationMain(0, nil) $ macrubyc prelude.rb DemoView.rb PathDemoController.rb main.rb -o ../ MacOS/PathDemo $ rm *.o *.rb As you can see, here we created 2 additional files, prelude.rb and main.rb. prelude.rb loads the Cocoa framework and is passed as the 1st object, which means it will be executed at the very first time. This is needed since you want the framework to be loaded before executing code that would use it. main.rb just calls the Cocoa run loop, we pass it at the very end since this is a blocking call. Current issues: - It is very preliminary. Lots of bugs and only a portion of the Ruby AST is supported. The goal is to provide 2 modes: normal and full. Only the normal mode is being implemented right now. The normal mode will support the entire Ruby specification, compile input source files into machine code, and still use LLVM at runtime to generate stubs. This will be the preferred way to compile desktop applications. Startup time will be very good (almost like Objective-C) and the entire source code will be compiled. The full mode will compile everything statically and will not generate any code at runtime. Only a subset of the Ruby specification will be supported, and the final binary will not contain LLVM. This can be used when you want a very light application and/or if the environment does not support runtime code generation. - It can only produce 64-bit binaries for now. Universal binary support will come in the future. - It heavily depends on the linker ordering in order to initialize things. macrubyc might expose a way to call a "main" method that you would define in Ruby, after doing all the initializations. If you have any comment, criticism or suggestion please do not hesitate. This is all shiny and we have the time to iterate on it :-) Laurent