Crystal Blog

> What kind of code snippets could you suggest? Anything really! Some websites that do this currently: https://ziglang.org, https://crystal-lang.org and https://www.ruby-lang.org/en > I have a comparison table mentioning features Yes - I did see this in the README. Maybe worth adding it, or something similar to the website.

Windfall, for those who want it. LLMs were fantastic for writing a project[0] in a new, niche language[1]. They help write any missing libraries. They help iterate when I get stuck on language aspects. They explain concepts as well as the median SO post, and much better than the posts that don't exist. [0] https://github.com/TedSinger/chatfile/ [1] https://crystal-lang.org/ - quite pleasant

You won't ever see fast compilation times with it, and here's why: > type annotations are rarely necessary, thanks to powerful type inference. This keeps the code clean and feels like a dynamic language.[1] I prefer Sorbet[2] for Ruby, which is pretty fast and a reasonable compromise. People complain about the verbosity, but you can't have both speed and type inference. Pick one. Some of the verbosity in Sorbet, however, comes as an indirect result of an underdeveloped Generic type system (the rest of the parts work great though). Some of the verbosity comes from lack of fluency with the tool, which gets better with practice, and doing research. The bottom line is I often think its a skill issue when people say it leads to code that is too verbose. 1. https://crystal-lang.org/#type_system 2. https://sorbet.org/

Obviously as an interpreted language, it's never going to be as fast as something like C, Rust, or Go. Traditionally the ruby maintainers have not designed or optimized for pure speed, but that is changing, and the language is definitely faster these days compared to a decade ago. If you like the ruby syntax/language but want the speed of a compiled language, it's also worth checking out Crystal[^1]. It's mostly ruby-like in syntax, style, and developer ergonomics.[^2] Although it's an entirely different language. Also a tiny community. [1]: https://crystal-lang.org/ [2]: https://crystal-lang.org/reference/1.10/crystal_for_rubyists/index.htm…

BACKEND: It's about 3000 lines of Crystal code https://crystal-lang.org/ -- it's been an absolute dream to program in. Ruby-like syntax, statically compiled performance. Nice standard library. Would recommend :) Performance == caching Local ephemeral filesystem for shortest-term caching. Redis for shared medium-term caching and locking. S3-compatible object storage for longest-term caching (for raw data feeds pulled every evening by a cronjob). FRONTEND: Bootstrap uPlot https://github.com/leeoniya/uPlot Just a sprinkle of inline JS+CSS on the page.

The Crystal programming language is very nice. It is a typed, compiled language with excellent performance. The syntax is inspired by Ruby but is not identical to Ruby (by design). The all-important version 1.0 milestone was reached in March 2021. The next version (1.3) is scheduled for release in January 2022. Some downsides to Crystal: - No Windows version: Estimate for a Windows version is still not known - this will obviously turn away Windows developers. Crystal can be run via WSL (Windows Sub-system for Linux), but it's not ideal. - Slow(ish) compilation. - Small community: This isn't necessarily a problem, but as a new language you won't find the same learning resources and online discussions as more popular languages. However, the standard library is quite well fleshed out. https://crystal-lang.org/

It's a Crystal [1] app built with the Lucky Framework [2]. The source code is here [3] and there are a few instructions in the README for deploying, but not much yet. [1] https://crystal-lang.org [2] https://luckyframework.org [3] https://git.sr.ht/~edwardloveall/scribe

> In the next 20 years I expect Go will be supplanted by a language which is a lot like go (automatic memory management, simple, easy to learn & write and performant enough) but with the addition of algebraic data types, named parameters, and a slightly higher level of abstraction. I'd love for this to be Crystal: https://crystal-lang.org/ > I haven't seen server work being done in Java in ages. In the meantime, I've been doing a large amount of Java backend server work for the past 10 years.

If you’re ok with s/python/ruby Crystal is great, LLVM compiled and has a couple of cool web frameworks coming up. https://crystal-lang.org/

> The rails (or Ruby in general) toolset really impressed me and I’m using Ginkgo at my current job to get my fix for BDD / specs. This is, I suspect, the biggest win from the Ruby/Rails ecosystem. Rubyland went hard-core TDD a long while back -- I suspect largely due to the influence of Pivotal Labs -- and the maturity of the toolset and automation really reflects that. Every time I work in another language, I find myself very much missing both the Ruby toolchain and (depending on the language) the everything-is-an-object approach. Not to say that Ruby is perfect, but the tooling really is that good, which is pretty amazing given that Ruby isn't exactly the most parseable of languages -- although on that front, I've got a lot of hope for Crystal: https://crystal-lang.org

Gleam[1] is a typed language on the BEAM. It's still in its early days, more so than Rust. May still be worth keeping an eye on. Nim[2] and Crystal[3] also exist. No idea what their web situation is like, but Nim has a JS compile target, that might be interesting. [1] https://github.com/gleam-lang/gleam [2] https://nim-lang.org/ [3] https://crystal-lang.org/

I'd suggest taking a dip into crystal - I've been tracking it's development and it could be my next general purpose language, it's what you're looking for too I believe - to quote the docs: Crystal is a programming language with the following goals: * Have a syntax similar to Ruby (but compatibility with it is not a goal). * Be statically type-checked, but without having to specify the type of variables or method arguments. * Be able to call C code by writing bindings to it in Crystal. * Have compile-time evaluation and generation of code, to avoid boilerplate code. * Compile to efficient native code. https://crystal-lang.org/ IMO It's the next hacker's language of choice.

Thanks! One of our sub-values is boring solutions https://about.gitlab.com/handbook/values/#efficiency So I don't think we'll be creating a programming language soon. I'm following crystal https://crystal-lang.org/ with interest. And one of our team members is making one in a private capacity https://gitlab.com/yorickpeterse/inko

ok this is going to sound snarky but it's an honest question: Why not just use Crystal[1]? It's basically just compiled ruby with static types, and it can infer types correctly in most cases without you explicitly noting which they are. The best argument for this (instead of Crystal) is keeping access to ruby gems. [1]: https://crystal-lang.org/

While the article mentions at the end the Crystal[1] language. I will say that I found that C# with generics was very approachable, and F# has always been interesting. Wish some of the changes approaching with the acquisition of Xamarin by MS, the openness since ASP.Net MVC, and now .Net Core it's worth looking at again. I've been in JS/Node land for most of the past 6 years now, and tbh, I've enjoyed it thoroughly, but I wouldn't mind dabbling back in modern C# without some of the "Enterprise" patterns that were way over-used. On the flip side, I still just don't care for Java. Even then, some of the things I might reach for C# to do may be a better opportunity to get into go or rust. Definitely some interesting opportunities all around. [1] http://crystal-lang.org/

I've enjoyed Crystal (https://crystal-lang.org/) a lot lately. Others have mentioned Nim, which is quite good. Also, D-lang (http://dlang.org/) doesn't get nearly enough love by people. It's an excellent language too.

I find a great answer in this area is Crystal. I consider it 'go in ruby clothing'. Like go, Crystal is a typed language and outputs binary executables. They kept the beautiful ruby syntax and made better internals. http://crystal-lang.org/

One of the great things about Ruby at the moment is the number of Ruby implementations around, including several Ruby like languages which attempt to do things slightly differently. Crystal is one language with Ruby like syntax and the goal of compiling to efficient native code. ( http://crystal-lang.org ) Mirah is another statically typed Ruby like JVM based language, although its development is a bit slow. (http://www.mirah.org)

> [...] I’ve used a number of languages and dabbled in a few frameworks but nothing I’ve used brings me joy like ruby does. Totally agree, 100%. Ruby isn't "perfect", but it's a pleasure to use. As in, I actually want to use it, not just am "ok" or ambivalent about it. I have my nitpicks about Ruby, about Rails and other things just like anyone, but I second your comment that nothing else has been able to match that sweet spot of great productivity that is a direct result of a fantastic developer experience created through a programming language that just "flows" linguistically so much easier than...well, everything else I've personally ever seen (with Python being an arguable tie there). My biggest gripes about Ruby and its ecosystem have been the pain in the posterior it is to deploy apps (all those gems, which eventually wind up abandonware and now you've got dependency hell, especially with apps not maintained in 5 years or something) and its relative sluggishness when compared against some other deployable artifacts. Personally, I think Crystal (https://crystal-lang.org/) fixes pretty much all of this, as long as you're willing to cede a few things due to the nature of the beast (compiled vs. interpreted). And that's not considering the speed improvements Ruby's gained in the last few years (3x3); it's undoubtedly far better now than when I last released an app with Ruby or Rails (circa ~2016, maybe ~2017ish). I'm just so disappointed that everything's "JavaScript…

Although I mostly agree with you, it's worth noting that static typing only goes so far. When I worked in a large-scale Java codebase, it always seemed like half the code only existed in order to "work around" the type system. (Don't even get me started on Spring, which might as well be a whole additional language on TOP of the actual application code.) I'm perfectly willing to grant that might just be a Java thing, but still, it was a huge and constant frustration. Because of the above, types really don't seem like "useful docs" to me. I get extremely irritated when a library links to its API documentation and it's all just autogenerated lists of methods which proudly state their parameter and return types but say absolutely nothing about what they do. That's one major thing I've always appreciated about the Ruby and Javascript ecosystems: because they can't rely on type information, most libraries go out of their way to describe how they work in depth. I'm willing to grant that I didn't have a ton of experience with Java before moving on to other languages, and so I could very well be wrong... but one thing that definitely worries me about Typescript is the increasing Java-fication of browser languages. Now, all that being said, I gave Crystal [0] a spin the other day and it's a freaking dream. Ruby, but with types, and compiled to LLVM? YES PLEASE. 0: https://crystal-lang.org/

As a Ruby/Rails dev, the OP makes a good, directionally correct point: "I don’t believe that simply being better than Rails is enough to displace Rails." However, he's off by a bit. It's going to take another framework to not just be "simply better". This framework will need to be an order of magnitude better to get me to switch from the amazingly productive Rails ecosystem. The framework/language marketplace is crowded and you are going to really need to standout to get any serious adoption to compete. For me, the cost of switching all new development projects to Hanami seems to out-weight the benefits (this also assumes Rails is the correct tool for the job of course, which it often isn't). That said, a Rails/Hanami/Sinatra framework built on the Crystal language, which looks almost exactly like Ruby but gives you C performance, appears like it might be that order-of-magnitude to 100x game-changer that could get me to switch stacks. [0] Whether you like him or not, Peter Thiel has some good thoughts when it comes to innovation and I think this argument perfectly encompasses this Rails/Hanami discussion: "As a good rule of thumb, proprietary technology must be at least 10 times better than its closest substitute in some important dimension to lead to a real monopolistic advantage. Anything less than an order of magnitude better will probably be perceived as a marginal improvement and will be hard to sell, especially in an already crowded market. The clearest way to make…

Go is an early entrant into this space, but I think part of the reason it is early is also that it is less ambitious. But to answer the ever-present question on HN about "why would anyone ever use this language?", something modern, almost as easy to use as a scripting language [1], and almost as fast as a compiled language, doesn't actually have a lot of contenders. (Old fogeys... like me!... like to observe that if you drop modern you have some things like Delphi that fit that slot, but they're all pretty much dead now, and Go has good support for concurrency in the modern processor environment.) In the "you probably can't convince your boss yet" category I'd recommend Crystal (https://crystal-lang.org/) and Nim (https://nim-lang.org/). Given the programming landscape and the general direction of things lately, I also bet there's a couple of serious contenders developing out there that haven't even hit HN yet. [1]: For at least a broad class of problems. Put Go head-to-head with a problem someone would use NumPy for and Go will go down in flames in the ease-of-use and line count department. However I use Go for a lot of networks servers (not even necessarily Web servers, but network servers) and the line count for these comes out maybe 20% larger than Python, and it doesn't take much developer cognitive energy for those extra lines. I've also used Go for some command-line type apps where the line count is probably 50% over Python, but I also got some significant wins…

Our main proxies (that do the majority of the heavy lifting over here) run nginx and use, what, 50MB tops? If even? I throw them on $5/mo VPS instances and they just blast out IO without any problems. But nginx was carefully written in C over the course of many years, with a general goal of hauling IO and static data around from other systems. Which is all you really need for web pages, in the end. Solved one thing and holy crap they did it well. It's the business logic side of the web development world where things get nasty. The tradeoff is you get a giant chest of libraries for solving any stupid problem you want. I didn't have to for example figure out how to do IDN encoding for domain validation. You throw enough of that crap together in a single process and things start to get nasty. But how long would I have spent carefully writing all of it in C? Let's just say I'd be out looking for another job. Worth the tradeoff, IMHO, but I think with projects like Crystal (https://crystal-lang.org) in the future we will discover we can get pretty close to both in the end. That combined with Moore's law and I think we'll be good to go. Assuming, of course, that cloud providers don't artificially restrict available RAM through economic constraint (know the true costs - demand better!).

Here is a list of similar languages that operate on the fringes and work in a similar compiled-yet-readable (somewhat) fashion: http://nim-lang.org/ http://crystal-lang.org/ http://lbstanza.org/ (posted a few days ago) Here is the 1 clear and important problem these languages have (which is similar to the marketplace-dilemma for ebay-type businesses): They lack support from the community because the community would come only if they had a strong set of libraries/packages to do "actual" work OR if they had the financial-muscle of a big company backing it (Go from Google being the prime example) AND they need the community to actually build these frameworks/libraries to make the language popular/usable to more than 40 people. If any of these languages want to expand beyond "we're an amazing systems-language that you can build: games, web applications, OSes, desktop applications, mobile applications with", they need to focus on a problem-domain and address it. Here are some examples: - Elixir - although not explicitly saying it, with the rise of Phoenix, they are clearly targeting web-backends with good performance - Kotlin - Java is shit, so they are addressing the Android issue with a language that some say is better I'm not exactly sure what specific problem-domains the 3 languages above are addressing, but ask yourself this: If you are going to use a systems-language (similar to those above) to build some micro-service or web backend, why use anything over than…

Sounds a lot like Crystal, which is also similar to Ruby and features a green fiber runtime: https://crystal-lang.org/#concurrency

> 1. Go with a better type system. A compiled language, that has sum types, no-nil, and generics. I was looking for something like that and eventually found Crystal (https://crystal-lang.org) as a closest match: LLVM compiled, strong static typing with explicit nulls and very good type inference, stackfull coroutines, channels etc.

wondering why https://crystal-lang.org/ hasn't been mentioned in the comments

I'm surprised that Crystal[1][2], a heavily inspired by Ruby compiled language, was not mentioned in all of this. Though it has more of an issue than Elixir, where various people can feel it has not gained enough traction[3][4] (according to various rankings). Elixir at least ranks in the top 50, per TIOBE. [1]: https://crystal-lang.org/ [2]: https://en.wikipedia.org/wiki/Crystal_(programming_language) [3]: https://archive.md/sJRyf (TIOBE November 2025) [4]: https://www.slant.co/topics/15430/~compiled-programming-languages (Slant Rankings)

That's exactly the essence and the power of Ruby. If you want static typing, compilation, performance with Ruby-like syntax just use Crystal https://crystal-lang.org/

Crystal [0] is what comes to mind. I've spent very little time with it, but I find the syntax very appealing. [0] https://crystal-lang.org/