[branchly2]

Alas, this ambitious project appears to be not currently under active development.

My largely uninformed armchair opinion as to why, is that the author is very performance-driven, and in the end it's very difficult to beat the JVM performance-wise. Lesson: if you want high-perf Clojure, you already have it on the JVM.

Personally, I think there's room for a simple small native Clojure implementation where performance is not top-priority. Small footprint, quick startup, access to native C libs. Still holding out hope for that one.

[nickik]

Its a hobby project, its not nearly done, don't use it in production.

But, that said, that is basically what it is: https://github.com/clojit

I would love to write a JIT for it, but currently its a half done interpreter. You compile Clojure to Bytecode (of our own design, see clojit-doc) and a C interpreter (we started in Rust but the pre 1.0 chances and some other stuff killed that).

All of this is inspired by LuaJit, specifically my goal is to work on a tracing compiler. It just takes to much time to get there.

[yellowapple]

I'm generally in demand of small, quick startup, easy-to-embed languages that aren't Lua (I can't stand Lua; I feel like every time I've had to deal with Lua code was far more painful than reasonably possible). There's mruby and maybe a couple others. I was hoping Pixie might be another contender in that space, but it doesn't seem to be after all (or if it is, it's very poorly documented to that effect).

I've been tinkering with some ideas for another language in that space (the Crafting Interpreters book is looking to be pretty helpful in getting me there: http://www.craftinginterpreters.com/), but it'd be really nice if there were enough options for me to not feel the need to create my own.

[networked]

A list that I maintain might help you find one: https://github.com/dbohdan/embedded-scripting-languages. Personally, I am a fan of Jim Tcl (http://jim.tcl.tk), especially for when you need a small interpreter that knows how to interact with its Unixy environment (i.e., the file system, processes, sockets and UTF-8 text data) out of the box.

[yellowapple]

Jim Tcl actually looks about damn perfect. I'll definitely have to give that one a whirl.

[mark_l_watson]

In the last, I have been very happy with Gambit Scheme for building small pre-compiled executables for command line utilities, etc. A lot of people use Chichen Scheme for the same purpose.

[m-j-fox]

https://common-lisp.net/project/ecl/

[jacobush]

Picolisp. I found it very easy to embed.

[kimi]

There is Ferret - http://ferret-lang.org/ or https://github.com/nakkaya/ferret

From the docs: "Ferret is a free software Clojure implementation for real time embedded control systems"

[hota_mazi]

> it's very difficult to beat the JVM performance-wise

Especially in Python, which is what Pixie is written in.

I don't think a performance-driven developer would have picked Python in the first place.

[stable-point]

It is not written in Python, it is written in RPython:

> So this is written in Python? > It's actually written in RPython, the same language PyPy is written in. make build_with_jit will compile Pixie using the PyPy toolchain. After some time, it will produce an executable called pixie-vm. This executable is a full blown native interpreter with a JIT, GC, etc. So yes, the guts are written in RPython, just like the guts of most lisp interpreters are written in C. At runtime the only thing that is interpreted is the Pixie bytecode, that is until the JIT kicks in...

[throwaway91111]

It's written in rpython; I don't understand why it couldn't be competitive with the jvm.