It’s official. This Wednesday marks my last day in my programming career as I hand in my badge, metaphorically speaking, to fully dedicate 2025 to launching my programming language, jank. This transition has been a long time in the making, evolving gradually, but let’s delve into the journey of how I arrived at this pivotal decision.
The Genesis of Jank
A decade ago, precisely ten years to this month, my fascination with programming language design and compiler development began. At that time, I was deeply immersed in the world of C++ and my professional life revolved around building game engines. My aspiration was to create a language that would empower the development of safer systems, boasting incredible compile-time metaprogramming capabilities and a robust framework for managing parallelism. I had encountered the practical constraints of C++’s template metaprogramming and the daily challenges of parallelizing a substantial, monolithic in-house game engine at my workplace.
This realization led me to explore a wide spectrum of programming languages. To those in the Rust community resonating with my objectives, yes, I embraced Rust over 12 years ago. It was a revelation. Alongside Rust, I also explored Common Lisp, OCaml, Factor, Haskell, and ultimately, Clojure.
Around this period, I reached out to Dr. Christian Schafmeister regarding his project, Clasp. Clasp is a Common Lisp implementation built on LLVM. He was developing something remarkably similar to my vision, although my inclination was to draw more inspiration from Clojure than Common Lisp. I contemplated joining forces with him, and we discussed this possibility. However, in the end, I decided to forge my own path. Nevertheless, the existence of Clasp served as a significant source of motivation for me. It demonstrated that my goal was achievable.
Eight Years of Iteration and Growth
Among all the languages I experimented with, Clojure and Rust stood out as the only two with enduring influence. Both languages profoundly reshaped my approach to writing code and conceptualizing programs. Rich Hickey’s talks, in particular, were mind-opening. Throughout these eight years, I iteratively rewrote jank multiple times, each iteration embodying a different design, in pursuit of something that felt inherently right. My ambition was to synthesize the elements I admired in C++, Clojure, and Rust. Admittedly, this was a formidable challenge, considering the stark contrast between Clojure and both C++ and Rust.
During this extensive period, my professional life continued to evolve. I remained involved in C++ game engine development, co-founded an e-sports startup built entirely on Clojure full-stack for five years, and subsequently joined EA, contributing to web product development using Clojure as well.
Concurrently, my personal project, jank, continued to evolve. I deepened my understanding of Clojure and gradually refined my objective: to bring Clojure into the native execution environment. This clarity of vision propelled the development of the latest version of jank over the past two years, accompanied by an expanding jank community, largely drawn from the existing Clojure community.
The Momentum of the Past Two Years
Once I had a clear direction for jank, the critical need became more dedicated time for its development. To initiate this, I transitioned to a part-time role at EA, working three days a week and dedicating the remaining four days to jank. I actively engaged with the Clojure community by speaking at and attending conferences in the US and Europe, participating in podcast interviews, and publishing articles in collaboration with other tech communities. I established jank’s online presence, including its website and blog, and focused on nurturing its burgeoning community. Above all, I invested significant effort in building a native Clojure dialect on LLVM. This endeavor involved approximately 1200 commits, a testament to the intensive development process. Another notable metric is around 1000 files changed, encompassing nearly 60,000 lines of code modifications.
The result? jank’s popularity witnessed an extraordinary surge.
Today: A Pivotal Moment
Currently, I believe jank holds the position of the most popular unreleased Clojure project, closely followed by HumbleUI. The level of community support and interest is truly vibrant. I regularly receive messages, emails, and inquiries from individuals eager to know when jank will be ready for practical use. I’ve engaged in discussions with founders and tech leaders from numerous companies at various Clojure conferences and meetups, all expressing interest in leveraging jank to address performance, efficiency, usability, or interoperability challenges within their Clojure ecosystems.
For the past five quarters (15 months), I have consistently applied for and received funding grants from Clojurists Together each quarter. While these grants don’t fully cover living expenses, they provide substantial support and further underscore the community’s strong belief in jank.
However, it’s crucial to acknowledge that jank is not yet complete. A significant amount of work remains to be done.
I often find myself feeling constrained by time, both daily and weekly.
The momentum behind jank is palpable, and I’m determined not to lose it. I don’t want to miss this crucial window of opportunity.
Moreover, I realize that there is nothing else I would rather be working on.
Therefore, I have made the decision to leave my job at EA to fully dedicate myself to jank.
Fortunately, I am privileged to be in a position to make this choice. I am indeed relinquishing a fulfilling role at EA. I held a leadership position within a product I helped create, working part-time while retaining my benefits. It was an exceptional arrangement, and EA was a commendable employer. I am trading this stability for financial uncertainty and foregoing the potential for significant financial gain. Instead, I am gaining something far more valuable: significantly more time to dedicate to the project I am deeply passionate about.
I am exchanging a stable career for the freedom to hack.
My Financial Strategy for Full-Time Jank Development
A common question I encounter revolves around my plans for jank, especially considering my decision to forgo a steady income to work on it. In simple terms, my primary objective for 2025 is to release jank and be genuinely proud of the final product. I derive immense joy from developing my projects and am thrilled by the community and momentum that has already been established. I want to fully embrace and enjoy this phase. Rest assured, jank will always remain free and open source. It is a project born from my own aspirations, but it is also my contribution to the community.
Could I potentially create enough value for the Clojure ecosystem to attract a company willing to financially support my continued work on jank? Yes, that would be the ideal scenario, provided I can maintain autonomy over my work. However, even if this doesn’t materialize, I am committed to dedicating the entire year to jank and ensuring its release. Next year, I will reassess the situation and make decisions for 2026. Regardless of the financial outcome, my commitment to jank remains unwavering. This journey began a decade ago, and I anticipate continuing to develop jank in some capacity for at least another ten years.
In the interim, I will continue to encourage individuals to support the project through Github sponsorship, actively seek out open-source grants, further cultivate the community, and, most importantly, keep building jank.
Roadmap for Jank in 2025
The year ahead is packed with essential tasks. Here are the top ten priorities for jank development:
- Improved error reporting for a smoother user experience.
- Seamless C++ interoperability to broaden jank’s applicability.
- Whole-project AOT (Ahead-of-Time) compilation for performance optimization.
- Achieving parity with the core Clojure libraries to ensure compatibility and functionality.
- nREPL server support for enhanced development tooling.
- Leiningen and deps.edn support for seamless integration with Clojure build tools.
- Packaging and distribution of jank across major Linux distributions and macOS for accessibility.
- Comprehensive documentation to facilitate adoption and usage.
- Extensive stability and robustness testing to ensure reliability.
- Outreach, support, and community development to foster growth and collaboration.
While completing all these objectives within 2025 might be ambitious, I am committed to making significant progress on each to ensure jank’s successful release.
Expanding Beyond Native Clojure
As I mentioned earlier, a native Clojure is the initial step towards my envisioned dream language. My ambitions extend beyond simply replicating Clojure in a native environment. While jank will always remain a Clojure dialect, it will also explore optional enhancements. Features such as gradual typing (potentially linear typing), more explicit memory management, value-based errors, and enhanced pattern matching are being considered to build upon Clojure’s foundation. These additions will provide an additional layer of control, allowing certain parts of a program to remain dynamically typed and garbage-collected while others are meticulously controlled and highly optimized. This granular control is precisely what I seek in a programming language.
In Summary: The Journey Continues
This journey has been extensive thus far, but this is merely the beginning. Envisioning the future, I anticipate new game engines built with jank, jank integrated into existing game engines, GUI development, web services, jank support in popular libraries, WASM builds, and, crucially, exceptional performance to underpin it all. The potential is immense and exciting.
Thank you for joining me on this journey.
Would you like to help out?
If you are interested in contributing to jank’s development, community, or have ideas to share, please reach out! Your support and involvement are highly valued.
