Rubinius Blog

I'm using Rubinius, the C++ implementation of Ruby in conjunction with Puma. (http://rubini.us) I'll definitely check out Data Dog and New Relic, thanks for the tip

Enova Financial in Chicago employs Brian Shirai to work on Rubinius, a new implementation of Ruby. http://rubini.us/

also almost off topic but the lead Rubinius dev just posted a great writeup on rubinius 3.0 which could be a possible future of ruby in general. http://rubini.us/2014/11/12/rubinius-3-0-part-3-the-instructions/

There are many Ruby implementations, a very popular one is Rubinius which is implemented in Ruby http://rubini.us/ The MRI or Matz's Ruby Interpreter (also called CRuby) is the reference implementation (Though RubySpec started by the Rubinius project has become the standard). Other implementations are very popular, such as JRuby that allows for running Ruby in the JVM.

I'm hopeful for Rubinius w/r/t a long-term viable polyglot VM. It has _lots_ of languages built for it but Ruby is still its most popular and mature as far as I know. http://rubini.us/

FTA: > We are still using MRI 2.0.0-p195 on Heroku and haven’t switched to either JRuby or Rubinius. Although there is a lot performance we could gain from this switch we are happy with the performance we have and it would make our development more complicated. From the Rubinius 2.0 release post[1]: > Evan created Puma to meet the need for a fast web server that would promote the Rubinius parallel thread support. Puma also works well on MRI and JRuby. It provides Ruby applications excellent performance and multi-core scaling, especially when there's no global interpreter lock. I'm very interested to see how much performance they would gain by switching to Rubinius, and why they say it would complicate their development. [1] http://rubini.us/2013/10/04/rubinius-2-0-released/

You're probably not serious, but for the OP this was the reason to start Rubunius X, as you can see here: http://rubini.us/2013/10/15/introducing-rubinius-x/ discussion: https://news.ycombinator.com/item?id=6553767 Personally I believe in "the best tool for the job".

Your statement sounds like sour grapes to me. When a language has multiple viable implementations, it means the language has a good specification. It also means that it doesn't depend too much on platform-specific characteristics. It means it is more portable. Python is both blessed and cursed with a couple of problems ... its behavior is sometimes related to the CPython implementation (e.g. reference counting, __del__), and also some libraries are too big and important to live without them. One such library is NumPy. Currently you cannot talk about an alternative Python implementation if you don't have NumPy running on it, and that's a fact. I'm a Python developer in my day job and I never used Pypy for anything. I only played with it and became frustrated that libraries I relied upon don't work on it. Btw, if you're a fan of Pypy, checkout http://rubini.us/

> but PyPy is one of the few things I envy Python developers for. Depending on your needs, there are others - numpy, scipy, matplotlib, nltk, gevent. > I wish something similar could be developed for Ruby. Isn't http://rubini.us/ supposed to be the PyPy for Ruby? It's not complete, but then neither is PyPy.

Maybe rubinius will fill this need? http://rubini.us/ Also, this could be an interesting read: http://www.engineyard.com/blog/2010/making-ruby-fast-the-rubinius-jit/

Check out rubinius, the bytecode seems to perform considerably faster than interpreted source: http://rubini.us/

Or you could just use http://www.jruby.org/ or http://rubini.us/.

For more information about Rubinius: http://rubini.us/ More language implementations on top of Rubinius: http://rubini.us/projects/

Both Ruby and Python have interpreters implemented in themselves. http://rubini.us/ http://codespeak.net/pypy/dist/pypy/doc/

Go to http://rubini.us/ "Rubinius is software that translates the code for the Ruby programming language [...] and turns it into efficient machine code like [...]"

I'd like to see if / how many of my unit tests pass using Rubinius, but does it currently support 1.9-specific code? Also, RVM installs RC2, not the 1.0 release. Maybe someone can give them a poke... UPDATE: Nevermind, http://rubini.us clearly states that 1.9 compatibility will happen post-1.0. Can't wait, even if it's just to know that my code is compatible with what may be a very real option in the years to come. AND: I should probably run "rvm update" first, to get the 1.0 release...

I'm so clueless as you. From http://rubini.us you can read "An environment for Ruby, the programming language that provides performance balanced with accessibility, focusing on improving programming productivity" The thing is, in this context, what is "an environment for ruby"?

Here, for starters: http://www.strongtalk.org/ http://rubini.us/ http://www.cons.org/cmucl/

I apologize, I should have said that this is my startup. I've been a long time reader of new.yc but never felt the urge to post. But I am pretty excited about what we are doing and so I was compelled to respond. My name is Ezra and my blog is http://brainspl.at if you have any interest in what I work on. The most exciting thing about what we are doing wasn't really covered in this article. The real news is about our Rubinius(http://rubini.us) and Merb(http://merbivore.com) projects. We are trying to improve Ruby as a platform for everyone.

This looks nice. I'm always excited to see higher level languages being used for scripting games. Lua is awesome at what it does but I've never really liked the syntax and lack of real objects. Building objects on top of Lua tables has always felt like such a hack to me personally. The one thing that always concerns me with Ruby engines, however, is distributing the un-obfuscated ruby files with a game. In a single player game, with no online leader-boards or other concerns of cheating it's fine. But in a game where someone might be tempted to cheat this just makes it too easy. I know obfuscating / compiling code isn't very strong security against cheating but it's a huge step up from distributing source files ready to be edited. Engines like Love2D (maybe other Lua based engines too, I haven't tried) allow you to compile your lua scripts and distribute the compiled versions. With Ruby I guess the options would be to make a Java game engine with JRuby then you're just distributing JVM bytecode. Or maybe building a native engine in c (like this one) but including Rubinius to run compiled Ruby code. Rubinius has a blog post suggesting that this should be possible (http://rubini.us/2011/03/17/running-ruby-with-no-ruby/) I'd love to see a game engine on Ruby with code obfuscation built in.

The ideas of Rubinius X will be added to Rubinius 3.0 over time, see the following articles for more info: http://rubini.us/2014/11/10/rubinius-3-0-part-1-the-rubinius-team/ http://rubini.us/2014/11/11/rubinius-3-0-part-2-the-process/ http://rubini.us/2014/11/12/rubinius-3-0-part-3-the-instructions/ http://rubini.us/2014/11/13/rubinius-3-0-part-4-the-system-and-tools/ http://rubini.us/2014/11/14/rubinius-3-0-part-5-the-language/

What I can't understand is why Ruby's standard implementation still has such terrible performance after all these years. Yes, the language is quite complicated, at least syntactically, but semantically it's similar enough to Smalltalk, and most Smalltalks have fast jitting VMs, including Squeak and Pharo (CogVM). The Ruby community is enormous by comparison and full of productive, opinionated developers who write tons of code, books, and blog posts, and yet the standard implementation (MRI) remains abysmal (sorry). It's really unfortunate that the MRI devs won't support Rubinius or event adopt RSpec to ensure interoperability with it: http://rubini.us/2014/12/31/matz-s-ruby-developers-don-t-use-rubyspec/

Almost offtopic because not directly related to symbols performances in Ruby but, coincidence, I was reading a 2011 post from Rubinius site http://rubini.us/2011/02/17/rubinius-what-s-next/ a couple of minutes before seeing this on HN. At almost 50% of the post there is a code snippet that explains why Ruby method calls must be slower than the ones of statically typed languages. It also explains how Rubinius was addressing that 3 years ago. Hopefully they'll optimize that in all language implementations.

If you want a GIL-less Ruby, check out Rubinius: http://rubini.us/2013/03/19/pdx-summit-recap/

Yes, sorry for not being clearer. I'm basing the "there hasn't been a release since 2011" comment off of the Rubinius homepage, where the last numbered release is 1.2.4. The Rubinius 2.0 preview release came out in June 2011: http://rubini.us/2011/06/07/inside-rubinius-20-preview/

I can't seem to find it, but I read an article about a compiler that brings another language to the python virtual machine!! "Is Python the platform of the future?" EDIT: here's a language running on rubinius (a ruby VM) http://rubini.us/2011/02/23/introduction-to-fancy/

I wonder if he gave Rubinius a go before switching to C++. IANAGD, but i'm guessing some of it's features would benefit game engines: Tunable GC, profiling (http://rubini.us/doc/en/tools/profiler/), JIT/LLVM. It wouldn't solve the C extension problem (maybe FFI does?) or distribution though.

This is a great overview about the two interpreters! However, I think you're being a bit inaccurate about how flexible the Rubinius VM is. It is certainly more than flexible enough to support a wide variety of non-Ruby languages. The core Rubinius team bas been working towards a language-agnostic core, and toolchains for building your own language on top of the Rubinius VM. See http://rubini.us/2011/02/17/rubinius-what-s-next/#multi-language-ualiz… and http://rubini.us/2011/02/23/introduction-to-fancy/ There are already a good number of language projects that build upon it: http://rubini.us/projects/ Fancy is one of the more mature languages built on it (and it's self-hosted): https://github.com/bakkdoor/fancy. There's even an (immature) Python that runs on top of it: https://github.com/vic/typhon.

Unrelated question: is there a reason the docs in the git repo aren't rendered at http://rubini.us/documentation? They seem well written and it'd be nice to be able to browse it from the website.