Jank Blog

> I keep itching to design a compiled functional language for games Jank wants to be this, right? IIRC its author and chief maintainer was a game dev before he dedicated himself to the language. https://jank-lang.org/ Maybe porting your engine would be a great way to prove out Jank 1.0 when it arrives ;)

Wondering whether a dialect like Jank [1] may be worth a shot? [1] https://jank-lang.org/

Along the lines of scripting is interactive programming. I'm working on a native Clojure dialect on LLVM with C++ interop, qalled jank. It can JIT compile C++ code, can be embedded into any C++-compatible application, and is a full Clojure dialect which doesn't hid any of its C++ runtinme. So you can do inline C++, compile C++ sources alongside your jank. and require them like a normal Clojure namespace. Worth a look if you're using C++ but you're craving something more interactive. https://jank-lang.org/

There's an effort afoot to bring this to the Clojure world, with the lovely name jank: https://jank-lang.org

I wonder if Jank [1] could be such a Lisp? I haven't played around with it, but I really like the idea and would love to see it get more traction. [1]: https://jank-lang.org/

As a person who looks always at Java and C sharp with curiosity, I am a bit divided. For me C#'s value is obvious in the frontend and also games compared to Java (except for mobile, where Java can be used but Kotlin seems best). But for the backend I always wonder if I should invest more on C# or Java as I go. Also, it worries me that Java is a memory hog, which C# seems not to be. I like to have lean server-side software, to the point that my usual approach has been to use C++ paired with Capnproto, but if I had to go with something a bit more high-level for web work, I am not sure. Currently I am investigating Clojure for non-critically-fast backend. It seems to be a lot of fun and since I am using https://fennel-lang.org/ (replacing part of my Lua code) and I expect https://jank-lang.org/ to become something at some point, maybe it is worth to stick to it? How would someone that has more data than me compare Java vs C# in terms of performance as-in "what machine you need in the cloud" to do useful stuff, mainly for backend work, asynchronous, in terms of CPU and memory for both?

I prefer https://jank-lang.org/ new re-design, and the approach of a more step-wise refinement.

Babashka is really nice indeed. Am hopeful for the C++ hosted Clojure dialect, Jank (https://jank-lang.org)

My depraved mind wants to see Jank [0] running on Fil-C, using Fil-C's garbage collector. [0] https://jank-lang.org/

Jank, a Clojure dialect, is playing in the same field: > Where jank differs from Clojure JVM is that its host is C++ on top of an LLVM-based JIT. This allows jank to offer the same benefits of REPL-based development while being able to seamlessly reach into the native world and compete seriously with JVM's performance. https://jank-lang.org/

You might be interested in https://jank-lang.org/ - still early days but full C/C++ interop is the plan.

A native clojure? have you seen jank? https://jank-lang.org/

Lately I've been using: https://janet-lang.org/ It's not a systems programming language, but it can be embedded in C. https://jank-lang.org/ looks interesting to me --I have not tried it yet. I'm not sure if this language could qualify as a systems programming language. What do you think?

Tangentially related clojure dialect compiling via C++ & LLVM: https://jank-lang.org/ jank has a progress page to give you an idea how much is implemented so far: https://jank-lang.org/progress/

Have you seen Jank? It’s a Clojure dialect being written in C++ and designed for interop with C++ instead of the JVM. https://jank-lang.org/

>If someone could give me the ergonomics of Clojure, but without the JVM and the ability to easily target 1/ native (incl easy bidirectional C iterop), 2/ wasm, and 3/ support both in aot and runtime + JIT modes, I would switch in a heartbeat. Might want to look at Jank (https://jank-lang.org/, https://github.com/jank-lang/jank). It's still in it's early stages but it's basically all you're hoping for!

Doesn't have to be: see https://jank-lang.org/, https://babashka.org/

Some dialects at various states of maturity: CLR: https://github.com/clojure/clojure-clr LLVM: https://jank-lang.org/ Erlang: https://www.clojerl.org/ Python: http://hylang.org/

There's an ongoing effort to create a Clang/LLVM implementation of Clojure's runtime with hot reloading and other very interesting features. You can take a look at it at https://jank-lang.org/. It still hasn't reached feature parity with full blown JVM Clojure but we've paying close attention to its development.

I also liked that reference since I had not heard of Jank before. It is a work in progress so I just added a calendar entry for 9 months from now to check it out. https://jank-lang.org/

There is also the jank language [0] that plays in similar fields. > jank is a general-purpose programming language which embraces the interactive, value-oriented nature of Clojure as well as the desire for native compilation and minimal runtimes. jank is strongly compatible with Clojure. [0]: https://jank-lang.org/

This isn't usable yet, but in active development by the author, and looks promising: https://jank-lang.org/

So basically https://jank-lang.org/ (assuming you don't mean literally it has to be Rust but just any LLVM clojure implementation)

This looks so cool! It does look like it has some technical similarities to Julia, with the LLVM JIT and such. It'd be great to see some benchmarks. Also see the GitHub[0], which looks like the author put a ton of work into this so far. Very impressive. That said, looking at the progress page[1], this is still far from achieving 100% feature parity. I'll be following it closely with my fingers crossed though. If you want to support this, it looks like the author is also accepting GitHub sponsorships[2]. [0]: https://github.com/jeaye/jank [1]: https://jank-lang.org/progress/ [2]: https://github.com/sponsors/jeaye

Thanks for clarifying. > I did have some issues with how Clojure is managed Yes there was some drama a few years back and then Rich wrote his post 'Opensource is not about you'. It was a good post. Opensource is not easy and you might argue the reason why Clojure is so stable and backwards compatible is because of the way it's managed. Luckily we didn't up with a scenario where Rich completely stopped. I think there was a recent case of an opensource maintainer (who works in academia) stopping PRs due to an entitled user. Can't remember the project. But equally, is the current form of stewardship fit for purpose for the next 10 years of Clojure, i.e. to increase adoption by businesses? Don't know. Maybe something can be learned from how Linux is managed. I think Linus experienced similar bottleneck issues back then. > I’m actually very interested in yank I think you mean Jank: https://jank-lang.org/ ? I'm quite excited about Clojure for GO projects. EDIT: clarity.

And we can look forward to Jank https://jank-lang.org/

Some good progress on Jank lately: https://jank-lang.org/

Soon there will be! https://jank-lang.org

As a dialect of Clojure, it's a dynamically typed language. But its designer has expressed interest in eventually adding static type checks via a gradual typing system¹: > I mentioned that a native Clojure is the first step toward my dream language. Indeed, it doesn't stop there. jank will always be a Clojure dialect, but it will also optionally support more. Features like gradual typing (maybe linear typing), more explicit memory management, value-based errors, and stronger pattern matching, to name a few, improve upon Clojure. This will allow another axis of control, where some parts of the program can remain entirely dynamic and garbage collected while others are thoroughly controlled and better optimized. That’s exactly the control I want when programming. -- 1: https://jank-lang.org/blog/2025-01-10-i-quit-my-job/