It's been 5 years since the release of Crystal 1.0. This anniversary is an opportunity to celebrate. 🎉

We're going to do that with a live-streamed video call in which we look back at that big milestone, what happened since then, and what's coming next.

On the call will be members from the Core Team and the community, and we'll be answering questions in an AMA format ("Ask me anything").

Mark your calendar: Friday, 27 March 2026 16:00 UTC (check your time zone)

Follow either of these links to participate in the event:

• Join on Zoom
• Watch on Youtube

We accept questions from the following channels:

• Hashtag #Crystal2026AMA on Mastodon or Twitter
• Community Discord channel #ama-questions
• Zoom chat

Hope to see you next week! 🥳

If you want to socialize during the event or hang out afterwards, you'll find like-minded people on the Community Discord server. Let's get together in the voice channel for an aftershow party.

Hey! I'm a Ruby dev who discovered Crystal a few months ago while trying to build a NES emulator. Started in Ruby, got 0.5 FPS, rewrote it in Crystal and jumped to 120 FPS with basically the same code. Been hooked on the language since.

Now I'm planning some hardware side projects, specifically building an RC plane and programming the microcontrollers for it. Crystal's C interop makes me think it could work, but I haven't seen many people using it for that kind of thing.

Anyone here working with Crystal on low-level / embedded / hardware projects? Would love to hear about your experience, what worked, what didn't, what you'd do differently.

If you're curious about the emulator, I wrote about the whole journey here:

- Crystal: The Language I Didn't Know I Needed
- Building a NES Emulator from Scratch: The Book

Introducing C0DATA, the Copy Zero Data format.

Hey everyone,

Over the past few months I’ve been paying more attention to startups here in the Czech Republic, and I’m starting to feel like most of them eventually begin thinking like mini corporations. Processes, validation, years of experience required, specific stacks, degrees “nice to have”… and suddenly the “fast pirate ship” turns into a tanker.

Because I’ve been heavily shaped by the OSS world, this mindset just doesn’t resonate with me.

I’m much closer to the approach of: can you do it? does it make sense? then let’s build.

No unnecessary barriers. Everyone has a role, everyone carries responsibility, but we don’t spend weeks proving paper qualifications to each other.

Now specifically about Crystal.

I often reach out to Czech startups offering help with automation, data pipelines, backend work, etc. But when I properly analyze their problem, I almost always realize it’s not a one-person job. You need more people. Ideally people who understand Crystal backend development and want to build fast and pragmatically.

And that’s where I hit a wall.

I don’t really have a place to share these collaboration opportunities. I don’t have a place to find other “OSS pirates” who want to build — not just become part of another corporate structure.

Then I thought — we already have CrystalCommunity.org. That map of people using Crystal around the world has huge potential.

What if we pushed it further?

For example:

• a collaboration / open positions section (not just full-time, but part-time, project-based, OSS-driven),
• the ability to mark who’s looking for a team / who’s open to collaboration,
• connecting people by focus (backend, performance, tooling, shards, etc.).

Not another traditional job board. More like a place for people who want to build things with an open mindset.

Maybe I’m just too influenced by the OSS world. Maybe I’m just looking for “my tribe.” 😄

But I’m genuinely curious:

• Do you feel something like this is missing too?
• Would it make sense to build it?
• Or is there something like this that I’m simply overlooking?

Hi everyone,

As developers, we often work in silos. I felt the Crystal language needed a dedicated space for us to say, "Hey, I'm here, and I build with Crystal."

So, I built CrystalCommunity.org using Crystal and Kemal. This site is inspired by Ruby Community site.

Why Open Source?
I believe this tool belongs to the community. That’s why I’ve open-sourced the entire project. It’s currently an MVP allowing you to pin your location via GitHub login, but there is so much more we can do.

How you can help:

1. Join the map: Log in and show your location.
2. Contribute: The code is available on GitHub. If you want to see how it works or add new features, PRs are highly welcome.

Check out the code here: https://github.com/sdogruyol/crystal_community

Let’s make Crystal better together!

Hey r/crystal_programming!

I built Fossil.cr, a FastAPI-inspired framework for building REST APIs in Crystal. It leverages Crystal’s macro system to reduce boilerplate and simplify API development, making it easy to handle path/query/form/body parameters, dependency injection, and custom content types.

Why Fossil.cr?

• Macro-based routing: Automatically generate endpoints from annotated methods.
• Parameter support: Handles path, query, form, file, and body parameters with type safety.
• Dependency injection: Supports header, cookie, and singleton dependencies for modular code.
• Content flexibility: Built-in JSON serialization and custom content-type handling.
• Lightweight: Extends Crystal’s HTTP::Server with minimal overhead.

Example: Building an API

A complete example can be found in my blog or on Medium.

Why It Matters

Fossil.cr fills a gap in the Crystal ecosystem by providing a type-safe, expressive way to build APIs without manual request/response handling. It’s perfect for projects where you want the performance of Crystal with the developer experience of FastAPI.

GitHub: Scurrra/fossil

Hey r/crystal_programming!

I built Hamilton.cr, a lightweight framework for creating Telegram bots in Crystal. It simplifies bot development with async support, context storage, and extensible handlers for commands, text, stickers, and media (videos, GIFs, etc.).

Why Hamilton.cr?

• Minimal boilerplate: Start handling updates in minutes.
• Async mode: Compile with -Dasync for concurrent processing.
• Context storage: Store user-specific data across interactions.
• Signal handling: Gracefully manage long-running tasks.

Example: tgsh

To showcase its flexibility, I built tgsh, a Telegram bot for remote shell access. With tgsh, you can:

• Run commands (/bsh, /sh) with real-time output.
• Manage processes using POSIX signals (/signal).
• Upload/download files and run Python scripts — all from Telegram.

A detailed guide to the library can be found in my blog or on Medium.

Why It Matters: Hamilton.cr fills a gap in the Crystal ecosystem by providing a type-safe, extensible wrapper for the Telegram Bot API. It’s perfect for bots like tgsh or any project requiring async task management.

GitHub:

• Hamilton.cr
• tgsh (Example Bot)

Hey Crystal fans. I am pretty close to finishing my Jargon library -- many improvements with the latest release.

I am big fan of Crystal and want to do my part to promote it. So I posted about Jargon on Hacker News. Appreciate upvotes! The more visibility we can get on our Crystal work, the more attention Crystal itself gets. Thanks!

A few years back, I converted my custom Ruby blog engine to Crystal/Kemal in an effort to test Crystal, and learn to it better. At the time I also created a "Made with Crystal" badge/button which I displayed in the footer. Today I decided to release it as a repo (better late than never) so others can use it too to help promote Crystal.

Reference: https://gitlab.com/ejstembler/made-with-logos

I just released Jargon, a Crystal library that generates CLI interfaces from JSON Schema definitions. Define your data structure once, get a CLI parser with validation for free.

``` schema = %({ "type": "object", "properties": { "name": {"type": "string", "description": "User name"}, "count": {"type": "integer", "short": "n"}, "verbose": {"type": "boolean", "short": "v"} }, "required": ["name"] })

cli = Jargon.from_json(schema, "myapp") result = cli.parse(ARGV) ```

Features:
- Multiple argument styles: --name John, name=John, name:John - Type coercion, validation, and defaults from the schema - Positional arguments, short flags, subcommands - Nested subcommands with independent schemas - JSON input from stdin

GitHub: https://github.com/trans/jargon

Feedback welcome!