
Rusthon – A Pythonic language that compiles to Rust and C++ - doublextremevil
https://github.com/rusthon/Rusthon
======
Demiurge
As I'm sure everyone, I was wondering, why... If you follow through from the
top to the blog, there is authors reasoning:

 _Introducing Rusthon

Rust is a systems programming language, and too low level for quick
prototyping, or simple web backends. It is nice to have all of the low level
control so you can fine tune performance later, but it should be optional.
Rusthon is a high level Python-like language that compiles to Rust. Rusthon
started as a fork of Gython, which is a fork of PythonJS.

The goal of Rusthon is simple and clean syntax inspired by Python. Rusthon
will allow you to code at a higher level than normal Rust code, and
interoperate well with hand written Rust and the Rust libraries. You can start
off writting your application in Rusthon, and drop down to hand written Rust
where you need more performance._

[http://rusthon-lang.blogspot.com/](http://rusthon-lang.blogspot.com/)

------
haberman
Compiling to Rust is a really interesting proposition, because it means the
resulting program has the same safe-without-gc properties as native Rust
programs.

~~~
quotemstr
Unless it transmutes pointers and uses unsafe blocks, of course. One of Rust's
most important features is that you _can_ do things like that. Hell, the
stdlib even has longjmp.

~~~
tomjakubowski
Really? Where's the longjmp function?

~~~
quotemstr
Err, I think I was mistaken.

------
Matthias247
Does this care about memory at all? In the transpiled code I see structures
getting allocated but never deallocated.

That will work for this trivial examples, but not for anything serious.

To properly translate Python to C++ you would have atleast produce a
_shared_ptr <T>_ from every _T_ and even that doesn't work with cycles. Rust
translation is even more complicated.

~~~
agentultra
It also doesn't even appear to generator initializer lists for the constructor
which could lead to some fun behaviors down the road...

------
sdfjkl
Reminds me of Nim (formerly Nimrod): [http://nim-lang.org/](http://nim-
lang.org/)

~~~
def-
Nim was also in the benchmark on the frontpage yesterday:
[https://news.ycombinator.com/item?id=8778041](https://news.ycombinator.com/item?id=8778041)

------
duey
Why would you use this over LLVM? e.g. pyston (LLVM Python) and then using llc
-march=rustc/c/cpp/whatever to convert?

~~~
rattray
Pyston is a very exciting project. The commit velocity on github seems quite
high [0]. Here's the latest status update on their blog, for those interested:
[http://blog.pyston.org/2014/11/21/pyston-status-
update/](http://blog.pyston.org/2014/11/21/pyston-status-update/)

[0] [https://github.com/dropbox/pyston/graphs/commit-
activity](https://github.com/dropbox/pyston/graphs/commit-activity)

~~~
techdragon
Except it's not targeting Python 3

Pypy is pushing towards full 3.4 slowly, which is good because I want some of
that Juicy STM support in my web apps.

~~~
BuckRogers
You are one of few concerned with Python3 targets. Pyston, PyPy are all mostly
Python(2) projects. PyPy3 does exist, but it's considered beta and not
recommended for production use as PyPy is.

Python(2) code/libraries will mainly survive on PyPy/Pyston going forward.
With stuff like Nim and Rusthon, I think something like those will carry the
torch forward after Python(2), rather than Python3.

------
amit_m
Cython already compiles to C and is relatively mature.

In my opinion these hacks will always be specialty tools. What the world
really needs is more languages that are both expressive and run pretty fast.
e.g. Julia.

~~~
shadowmint
Cython isn't the answer.

It's a neat tool, for sure, but it's a very specific thing, and it has several
down sides, mainly:

\- Every module compiles to a shared library.

\- Requires significant c infrastructure installed on the target machine to
compile.

\- Compiled code cannot be used without the python runtime.

This renders it almost useless for generating code for serious applications.
It's an adhoc solution to ffi and slowness because those are things are major
issues for python.

However, this (Rusthon) has some serious upsides:

The transpiled (if that's the word?) C++ / rust code is portable and fast.

It does not include the bloated standard python library.

It can be directly compiled using existing compiler tools for mobile devices
(to be fair, as the kivy-ios project shows, this isn't _impossible_ with
cython, but it involves patching the python source to load modules
differently).

~~~
andreasvc
> \- Every module compiles to a shared library.

How else would you import a module if it wasn't? If you want to reduce the
number of shared libraries you could put all your code in a single module, of
course.

> \- Requires significant c infrastructure installed on the target machine to
> compile.

Anything which involves compilation to native code requires significant
infrastructure.

> \- Compiled code cannot be used without the python runtime.

And this is a downside why? Combining the best of both worlds--native code and
Python--is the whole point. If you want to take out Python from the equation
just use C/C++.

~~~
shadowmint
The issues I pointed out are related to building distributable targets.

Shared library per module and 'wrapped' compiler execution for example, is
fundamentally hostile to distribution for mobile environments. Have a look at
the hoops kivy-ios jumps though. It's absolutely ridiculous.

That's the thing python is _the worst at_ ; building a single stand alone
application that does not require the user to install a copy of python and run
pip to download a million dependencies before it will run.

This isn't in question. It's just life; that's not what python is good at.

Cython doesn't solve that problem. It solves a different set of problems;
namely, ffi and speed.

My point is that by choosing an alternative approach (compile to portable C++
/ rust) this project gives you the benefits of ffi and speed _and
distribution_.

~~~
andreasvc
For Cython's intended audience, mostly scientific programming, distribution is
just not a primary concern, but rather efficiency and productivity. I think
the issues you cite are mostly the fault of the mobile targets themselves;
e.g., their app stores put up artificial barriers of which languages may be
used. On the server side or on a compute cluster having to pull in a bunch of
dependencies is absolutely no problem, and is the very reason the ecosystem of
Python provides productivity gains.

~~~
shadowmint
It's a little bit convenient to blame the platforms when your things don't
work on them.

The reality is that the tools (cython, python) were built without mobile
platforms in mind, and they (currently) are ill suited to supporting them.
That's not the platforms fault; it just an artifact of the development history
of the projects.

Cython is not a general purpose compile to C solution. It solves a different
problem to Rusthon.

/shrug

~~~
andreasvc
I see your point, Cython is not the right tool for the job when that involves
mobile platforms. I just thought that the claim in your original comment came
off as sweeping--"Cython isn't the answer"; you didn't mention that you had a
specific problem in mind.

------
andywood
Some comments here suggest the possibility of making manual changes to the
Rust code. After cross compiling, how does one make changes to the Rust code,
then go back and make changes to the Python code, and cross compile again
without losing the customized Rust code?

------
jumanji
[https://github.com/rusthon/Rusthon/blob/master/pythonjs/tran...](https://github.com/rusthon/Rusthon/blob/master/pythonjs/translator.py#L32)

if '\--cpp' [...] rust=True

Is that a bug?

~~~
broodbucket
[https://github.com/rusthon/Rusthon/blob/master/pythonjs/pyth...](https://github.com/rusthon/Rusthon/blob/master/pythonjs/python_to_pythonjs.py#L154)

Doesn't look like there's C++ flag in python_to_pythonjs, so I'd guess not.

------
chenzhekl
It would be great if it can interoperate seamlessly with existed C++ library.

------
lago

      # naming fix :)
      mv Rusthon Pythrust

