Forem: slick phantom

From Ruby to Crystal: Why I ported telegem to telecr

slick phantom — Wed, 15 Apr 2026 10:30:22 +0000

After my work on telegem (a Ruby gem for creating DSLs), I began to notice the stark differences between interpreted and compiled languages.

Ruby is fast, but for high-concurrency needs like Telegram bots, I wanted to see what Crystal could do. To my surprise, porting the logic worked beautifully. Today, I’m excited to announce telecr.

What is Telecr?

Telecr is a fast, fiber-based library for creating Telegram bots in Crystal. Think of it as telegem with superpowers.

Key Features

Blazing Fast: Leverages Crystal's performance and fiber-based concurrency.
Type Safe: Catch errors at compile time before they hit production.
Disk Backup: Reliable data handling.
Clean DSL: Designed for a great developer experience.

Quick Look at the DSL

 bot.command("start") do ctx 
   ctx.reply("welcome")
end

Join the Project

I'm officially opening this up for contributions and improvements! You can find the source code and documentation here:

slick-lab / telecr

A modern fiber based crystal framework for create telegram bots

Telecr

Telegram bot framework for Crystal. Inspired by telegem (Ruby).

Documentation

Full API documentation is available at: https://telecr.gitlab.io

Installation

Add to your shard.yml:

dependencies:
  telecr:
    github: slick-lab/telecr
    version: ~> 1.0.0

Then run:

shards install

Quick Start

require "telecr"

bot = Telecr.new("YOUR_BOT_TOKEN")

bot.command("start") do |ctx|
  ctx.reply("Welcome to Telecr!")
end

bot.start_polling

Features

Full Telegram Bot API support
Polling and webhook modes
Middleware system (session, rate limiting, file upload)
Reply and inline keyboards
Type-safe context objects
Session management with disk backup
File upload to shrine storage

Usage

Basic Bot

bot = Telecr.new("TOKEN")

bot.command("start") do |ctx|
  ctx.reply("Hello! I'm a Telecr bot.")
end

bot.hears(/hi/i) do |ctx|
  ctx.reply("Hi there!")
end

bot.start_polling

…

View on GitHub

I'm curious—have any of you moved a project from Ruby to Crystal? What was your biggest "aha!" moment during the port?

From Ruby to Crystal a detailed guide

slick phantom — Sun, 15 Mar 2026 12:04:08 +0000

I love Ruby. I still maintain telegem, a Telegram bot framework used by real people. Ruby pays my bills and makes me happy.

But I also wanted speed. I wanted binaries. I wanted to stop debugging "undefined method for nil" at 3 AM.

So I tried Crystal.

It looked just like Ruby. I was confident. Then the compiler yelled at me. For days. For weeks. For 64 failed pipelines.

This guide is what I wish I had on day one.

The Complete Guide: Ruby to Crystal

I just published a comprehensive, free guide for Rubyists moving to Crystal. It covers:

Quick Comparison - The "looks the same" trap

Side-by-side code examples showing where Ruby and Crystal diverge. Read →

The &. Problem - Why your favorite operator will fight you

How safe navigation works (and doesn't work) in Crystal, and the reliable patterns that always compile. Read →

Type System - Friend, not foe

Understanding union types, nil checking, and why the compiler is actually saving you. Read →

Hashes & Collections - NamedTuples will surprise you

The three ways to store data in Crystal and when to use each. Read →

Classes & Modules - Same but different

Instance variables, property shortcuts, and why self. sometimes saves the day. Read →

Require Order - The dependency dance

Why order matters and how to structure your project to avoid headaches. Read →

Common Errors Decoded - What the compiler is actually saying

A translator for those scary error messages. Read →

Why Crystal - The case for switching

Performance, safety, and peace of mind. Read →

🛠 Projects Built While Learning

The guide is free, but if you want to see real Crystal code, check out:

tg-auth - Telegram authentication for Crystal
telecr - Telegram bot framework (the Crystal version of telegem)

📖 Read the Guide

GitHub Repo: slick-phantom/ruby-crystal

The guide is completely free, open source, and ready for contributions. If you find something confusing, open an issue. If you want to improve it, send a PR.

Ruby gave me joy. Crystal gives me peace

I got tired or rewriting the same blog backend so I created a solution

slick phantom — Sun, 01 Mar 2026 10:28:35 +0000

Inkwell v0.1 — A lightweight, binary-compiled blog engine for developers who just want to ship.

The Problem

A client asked me to build a blog site. Cool. Built it.

Another client asked. Same thing. Built it again.

Third time? I caught myself writing the same create/post/delete/admin logic from scratch. Again.

I thought: There has to be a better way.

The Search

I went looking. Surely someone has solved this.

Found some stuff on GitHub. Looked promising until I dug deeper.

Good features? Locked behind paywalls.

Blog engine shouldn't be paid for.

So I decided to build one myself.

The Build

I needed something:

Compiled to binary — runs anywhere, no dependencies
Fast — no slow interpreted stuff
No bloat — does one thing well

Started with Go. Made sense. But I was still learning and progress was slow.

Switched to Dart. Things clicked. Built the core logic. Struggled through some parts. Learned a ton. Kept going.

Introducing Inkwell v0.1

It's basic. It's buggy. It works.

curl -sSL "https://gitlab.com/dart.co/inkwell/-/raw/main/install.sh" | bash
./inkwell

First run generates an admin token. Save it. Use it for X-API-KEY headers.

What It Does

For readers:

GET /posts — list all blog posts (reads from posts/ folder)
- GET /posts/:slug — get a single post as markdown
GET /search?q=query — search posts by filename and content
GET /feed.xml — RSS feed

For you (admin):

POST /admin/posts — create new post
PUT /admin/posts/:slug — update post
DELETE /admin/posts/:slug — delete post

All admin endpoints need your X-API-KEY.

How It Works

send posts to the create endpoint or read the Readme

The API reads them, serves them, searches them. No database. No config. No paywall.

The Current State

v0.1 is a prototype. I'll be honest:

✅ Core features work (create, read, search, RSS)
⚠️ Storage is just files (not fully safe, but lightweight) -🐛 It's buggy in places
🔧 Better storage solution coming in future versions

But for a solo dev who just wants to blog without the bloat? It gets the job done.

What's Next

Fix the bugs (help welcome!)
Find a better storage solution (keeping it lightweight)
Stable v1

Try It
git
Star it if you like the idea. Open issues if you find bugs. PRs if you want to help.

Or just use it and tell me what sucks. I can take it.

Built because rewriting the same code three times is two times too many.

Ubuntu: From "Linux for Human Beings" to "Linux for People with Fiber Optics"

slick phantom — Mon, 16 Feb 2026 11:12:57 +0000

I've been using Ubuntu for a while now. It was my first Linux distro — the one everyone recommended. "It just works," they said.

It doesn't anymore.

What Used to Be Good

Remember when installing software was simple?

sudo apt install spotify

One command. Done. No drama.

Ubuntu was the gateway drug to Linux. It was intuitive. It respected that not everyone has Google Fiber.

What Changed

Now try installing Spotify:

sudo snap install spotify

Looks simple. But behind the scenes:

core20 (20.04) 2024-05-07 from Canonical✓ downloaded
Wait... still downloading...
Error: Network failure
Retry? [y/N]:

If your internet fails during download? Start over from scratch.

The Runtime Nightmare

Every Snap app brings its own runtime baggage:

· Telegram needs core18
· Spotify needs core20
· VLC needs core22
· Something else needs core24

That's four copies of essentially the same thing. Hundreds of megabytes each. Duplicated. Wasted.

My system now has multiple core runtimes taking up space. For what? So Canonical can push Snap?

Who Is This For?

The current Ubuntu experience assumes:

· ✅ Fast, unlimited internet
· ✅ New hardware with storage to waste
· ✅ Time to troubleshoot failed downloads
· ✅ No concern about data costs

That's not "Linux for human beings." That's "Linux for privileged beings."

What About the Rest of Us?

· Students with old laptops
· People in areas with bad internet
· Anyone paying per megabyte
· Users who just want things to work

We exist. We're just not the target audience anymore.

The Alternative

Linux Mint Xfce.

· No Snap by default
· Normal apt packages
· Flatpak if needed (one runtime for all)
· Actually works offline
· Runs well on older hardware

One install. Apps install immediately. No core18/core20/core22 madness.

It's what Ubuntu used to be.

Bottom Line

Ubuntu had a good run. But it's no longer for everyone.

If you're struggling with forced Snap, duplicate runtimes, and offline installs that fail — you're not alone. And there are better options.

Sometimes the most popular choice isn't the right choice anymore.

Now am not criticizing Ubuntu it’s a great distro with gnome as default it’s cool with slick designs but the snap canonical is pushing is a terrible idea

Telegem first public plugin

slick phantom — Thu, 05 Feb 2026 11:33:11 +0000

Extract PDFs, JSON & HTML in Your Telegram Bot with Telegem's New Plugin

Building a Telegram bot that processes documents? Stop wrestling with file parsing. Telegem's new FileExtractor plugin lets you extract text from PDFs, parse JSON, and process HTML files in 3 lines of Ruby.

🚀 What This Solves

Before: Your users send PDFs/JSON files → You write 50+ lines of parsing code + install dependencies + handle edge cases.

After: Your users send files → You call one method → Get clean extracted text.

📦 Installation

# In your Gemfile
gem 'telegem'

# Install the optional dependency for PDF support
gem 'pdf-reader'

🎯 Real-World Examples

PDF Invoice Processor

bot.command('invoice') do |ctx|
  if ctx.message.document&.mime_type == 'application/pdf'
    extractor = Telegem::Plugins::FileExtractor.new(
      bot, 
      ctx.message.document.file_id
    )

    result = extractor.extract

    if result[:success]
      # Find amounts in invoice text
      amounts = result[:content].scan(/\$\d+\.\d{2}/)
      ctx.reply("📊 Found #{amounts.size} payment amounts")
    end
  end
end

JSON Config Validator

bot.on(:message, document: true) do |ctx|
  if ctx.message.document.file_name.end_with?('.json')
    extractor = Telegem::Plugins::FileExtractor.new(
      bot,
      ctx.message.document.file_id
    )

    config = extractor.extract

    if config[:success]
      ctx.reply("✅ Valid JSON with #{config[:content].keys.size} keys")
    else
      ctx.reply("❌ Invalid JSON: #{config[:error]}")
    end
  end
end

HTML to Markdown Converter

bot.command('html') do |ctx|
  if ctx.message.document&.mime_type == 'text/html'
    extractor = Telegem::Plugins::FileExtractor.new(
      bot,
      ctx.message.document.file_id
    )

    html = extractor.extract

    if html[:success]
      # Convert HTML to plain text (simplified)
      text = html[:content]
      ctx.reply("📝 Extracted #{text.length} characters")
    end
  end
end

🔧 How It Works Under the Hood

The plugin handles the tedious parts for you:

Downloads the file from Telegram's servers
Auto detects file type
Processes it with the appropriate library (PDF::Reader for PDFs, JSON.parse for JSON)
Cleans up temp files automatically
Returns a consistent hash format:

{
  success: true,
  content: "Extracted text here...",
  pages: 3,           # PDF only
  file_size: 45210    # All file types
}

⚠️ Important Security Notes

# ✅ SAFE - Use only Telegram-generated file_ids
extractor = Telegem::Plugins::FileExtractor.new(
  bot,
  ctx.message.document.file_id,  # From Telegram context
)

# ❌ DANGEROUS - Never use user input
extractor = Telegem::Plugins::FileExtractor.new(
  bot,
  params[:user_input],  # Malicious users could hack your server
)

🎨 Advanced: Processing Replies

# Extract from replied-to PDFs
bot.command('extract') do |ctx|
  if ctx.message.reply_to_message&.document
    file_id = ctx.message.reply_to_message.document.file_id

    extractor = Telegem::Plugins::FileExtractor.new(bot, file_id, file_type: :pdf)
    result = extractor.extract_pdf

    ctx.reply(result[:success] ? "✅ Done" : "❌ Failed: #{result[:error]}")
  end
end

📈 Why This Matters

Most bot frameworks make you handle file parsing manually. Telegem's approach:

· Reduces boilerplate from 50+ lines to 3
· Handles edge cases (encrypted PDFs, malformed JSON)
· Auto-cleans temp files (no memory leaks)
· Works seamlessly with Telegem's async architecture

🚀 Get Started

# Create a new bot
gem install telegem

# Check out the full example
git clone https://gitlab.com/ruby-telegem/telegem-examples

💬 Your Turn

What document processing tasks are you building with Telegram bots? Have you tried Telegem's new plugin? Share your use cases below!

Telegem is a modern, async-first Telegram Bot framework for Ruby. Built with ❤️ by @slick_phantom.

Why should we choose telegem over telegram-bot-ruby a established gem

slick phantom — Sun, 18 Jan 2026 19:42:38 +0000

In this post we are going to be two giants

providing ways to create telegram bots

Let’s take a deep dive into telegram-bot-ruby

telegram-bot-ruby

telegram-bot-ruby as I will call it tbr is a very good gem for creating telegram bots
it was quickly adopted by rubyist with many tutorials on sitepoint medium…
example code of tbr

  require 'telegram/bot'

# Get your token from @BotFather on Telegram
token = 'YOUR_BOT_TOKEN_HERE'

Telegram::Bot::Client.run(token) do |bot|
  bot.logger.info('Bot has been started...')

  bot.listen do |message|
    case message.text
    when '/start'
      bot.api.send_message(
        chat_id: message.chat.id,
        text: "Hello, #{message.from.first_name}! I'm a simple Ruby bot. Try /time or /roll"
      )

    when '/time'
      current_time = Time.now.strftime("%Y-%m-%d %H:%M:%S")
      bot.api.send_message(
        chat_id: message.chat.id,
        text: "Current time: #{current_time}"
      )

    when '/roll'
      # Roll a random number between 1 and 100
      number = rand(1..100)
      bot.api.send_message(
        chat_id: message.chat.id,
        text: "🎲 You rolled: #{number}"
      )

    when '/photo'
      # Send a cat photo (using a placeholder service)
      bot.api.send_photo(
        chat_id: message.chat.id,
        photo: 'https://cataas.com/cat'
      )

    when /hello|hi|hey/i
      bot.api.send_message(
        chat_id: message.chat.id,
        text: "👋 Hi there!"
      )

    else
      bot.api.send_message(
        chat_id: message.chat.id,
        text: "I don't understand. Try /start to see commands."
      )
    end
  end
end

what you notice

tbr is quite nice very nice it works out of the box but as you can see above it’s verbose Raw json raw api method nested arrays …

handling state conversions is very verbose and explicit

let’s picture a bot that does many functions The developers will have to handle spaghetti codes hard for a contributor without reading tbr docs to contribute

Then this is where telegem comes in
Telegem isn’t to replace tbr
instead it offers what tbr doesn’t and offers a clean dsl

no more verbose codes
no more raw json
no complexity or complex docs

Telegem superpowers

scene: one of Telegem great features
what scenes
Let’s take it as a system that automatically gets the text moves to the next step handles multiple conversations
psuedo code
signup
with scene it’s easy
What’s your name
Your email
your password
reply your account has been saved this is your api key

implementation

bot.scene :signup do
  step :ask_name do |ctx|
    ctx.ask "👤 What's your full name?"
  end

  step :ask_email do |ctx, name|
    ctx.with_scene_data(name: name)
    ctx.ask "📧 What's your email address?"
  end

  step :ask_password do |ctx, email|
    ctx.with_scene_data(email: email)
    ctx.ask "🔐 Choose a password:"
  end

  step :complete do |ctx, password|
    ctx.with_scene_data(password: password)

    # Generate fake token (in real app, use JWT or similar)
    token = SecureRandom.hex(8)

    # Get all data
    data = ctx.scene_data

    ctx.reply <<~TEXT
      ✅ Account Created!

      📋 Details:
      Name: #{data[:name]}
      Email: #{data[:email]}
      Password: #{data[:password].gsub(/./, '*')}

      🔑 Your Token: #{token}

      Save this token for future access!
    TEXT

    ctx.leave_scene
  end
end

usage: bot.command 'signup' do |ctx| ctx.enter_scene(:signup) end

telegem scene just works out of the box automatically moves the next step

Another method is ctx
ctx is an army you have different units and methods to use
ctx.reply
ctx.from.id
ctx.from.full_name
we won’t be talking about all this as it will take lot of time
our main focus will be ctx.reply
I find this method very easy to use
Basically let’s compare with tbr

telegem:

bot.command("start") do |ctx| 
ctx.reply("welcome to the world")

this is very easy unlike
tbr:

bot.api.send_message(
        chat_id: message.chat.id,
        text: "welcome to the world"
      )

digging up for chat.id
you just write ctx.reply

what’s more cool
you can use ctx.reply with options

keyboard = Telegem.keyboard do 
row "dev.to", "hashnode"
end 
ctx.reply("welcome to the world", parse_mode: 'Markdown', reply_markup: keyboard)

I am trying to keep this as short as possible

TL;DR
tbr is an old battle-tested gem with lots of tutorials and answers to most questions
telegem is a new async first gem focus on non thread and modern features such as auto ssl using a one line command telegem-ssl

use

use tbr if you want answers to most questions you could possible get
use telegem if you want a modern day gem with cool features that remove complex api methods

Telegem v3.1.0 is here

slick phantom — Sun, 18 Jan 2026 14:07:09 +0000

Telegem now has a stable version release and also some improvements

fixes

fixed the critical httpx bug preventing your bots from sending messages
fixed hanging scene system
fixed auto ssl detection method

New features

file extraction(file to text) plugins docs coming soon
new improvised scene system & middleware
Rate limit added can be used as a method also
Added cli for ssl

$ telegem-ssl your-domain.com

$ telegem-ssl 
#then enter domain when promted

Note: telegem doesn’t create a ssl it uses certbot
And should be only be used when using webhook mode

upcoming features

Oops 😬 won’t spill the tea 👍

Telegem v3.0.4 users : critical bug alert & call for help

slick phantom — Sat, 17 Jan 2026 18:50:19 +0000

If you are using v3.0.4 you might be experiencing

ERROR -- : ❌ Unhandled error: NoMethodError: undefined method `await' for an instance of HTTPX::Response(plugin)

This bug prevents your bot from sending responses or overall functionality

The issue is compatibility with httpx async api

What happened

Telegem v3.0.4 used an async pattern (response.await) that worked with old httpx versions but newer httpx release probably changed their async Api. This caused all api calls to fail when trying to send responses
especially the ctx.reply

Temporary solution

gem uninstall httpx
gem install httpx -v 0.22.0

we could use your help
Httpx is a fantastic library/gem with incredible performance. But it’s async api changes rapidly.As a solo maintainer
I could use some help from the community

Ways to contribute

TEST different httpx async patterns and share what works
Help document httpx compatibility across different versions
Submit MR(pr for github-ish) for more robust httpx handling
Share your use case

Let’s make Telegem rock-solid together

[Boost]

slick phantom — Sat, 17 Jan 2026 09:26:56 +0000

Alexandre Calaça

Nov 16 '24

Ruby: One of the top 5 highest-paying technologies, according to Stack overflow

#ruby #webdev #rails #programming

Comments 2

6 min read

Create a Telegram bot quote bot in Ruby

slick phantom — Sat, 17 Jan 2026 08:53:00 +0000

Create a bot quote bot to be precise

Requirements

Must have an ide
Basic or advanced knowledge in Ruby

project_folder/
├── bot.rb
├── quote.rb
├── help.rb
├── start.rb
└── Gemfile

Note: no .env here cause it’s meant to be secure and not to be commited to git

Let’s start with start.rb

#start.rb
 class Start 
    def initialize(bot)
       @bot = bot 
        start_handler
    end 
   def start_handler
      @bot.command("start") do |ctx| 
        ctx.reply("welcome to quote_bot use /quote to get astonishing quotes")
    end 
  end 
end

this file uses telegem two methods one .command this helps you with handling / commands e.g /help /start /quote and so on 
second is the ctx.reply method this is used to send a reply back to the current chat it automatically adds the id and it can take **options e.g reply_markup, parse_mode and so on with time you will eventually see how they are been used

help.rb

#help.rb 
class Help 
  def initialize(bot) 
     @bot = bot
     send_help_message 
   end 
  def send_help_message 
    @bot.command("help") do |ctx| 
   help_message = <<~TEXT 
     use /quote to get quotes 
   use /help to show this help message 
   TEXT
    ctx.reply(help_message, parse_mode: 'Markdown') 
    end 
  end 
end

-quote.rb

this is where knowledge in some gems is required in this special case we using httparty

require 'httparty'
require 'json'

class Quote
  def initialize(bot)
    @bot = bot 
     find_quotes
   end 
   def find_quotes
    @bot.command("quote") do |ctx| 
     response = HTTParty.get("https://zenquotes.io/api/random")
    if response.success?
      data = JSON.parse(response.body)
      quote_data = data.first 
       quote = quote_data['q'] 
       author = quote_data['a']
    message = <<~TEXT
    QUOTE OF THE DAY 
    quote: #{quote}
     author: #{author}
     credit: zenquotes
    TEXT 
    ctx.reply(message, parse_mode: 'Markdown')
  else 
     ctx.reply("failed to fetch code")
     end 
   end 
 end 
end

-bot.rb the main file

#bot.rb
require 'telegem'
require 'dotenv/load'

require_relative 'help'
require_relative 'start'
require_relative 'quote'

bot = Telegem.new(ENV['BOT_TOKEN'])

Start.new(bot)
Help.new(bot)
Quote.new(bot)

bot.start_polling 
puts "bot has started")

now we need our Gemfile

source 'https://rubygems.org' 

gem "telegem", "~>3.0.4"
gem "httparty", "~>0.21.0"
gem "dotenv", "~>2.8"

important don’t forget your .env

BOT_TOKEN=<your token here>

Now we need to install and run using bundle

-if you don’t have bundle gem still works or run

$ gem install bundle

now you can run using bundle but first let’s install all gems we need

$ bundle install

Then now we run our code

$ bundle exec ruby bot.rb

For more detailed examples
Visit repo

Star the repo
Visit the examples to study more examples

How to create telegram bots in Ruby

slick phantom — Thu, 15 Jan 2026 13:47:55 +0000

You must have heard or used telegram bots

now the deep question is how are they created

We are going to see to that get your ide ready cause we gonna create a bot in 5 minutes

Requirements

A ready good ide with Ruby installed
basic or advanced knowledge in Ruby
bot token from @botfather

If you don’t know how to get your bot token check out this post 👉 telegram_token

After getting you token
Create a GEMFILE

source 'https://rubygems.org'

gem 'telegem', '~> 3.0.4'

gem 'dotenv', '~> 2.8'

#add any other gem you wish httparty nethttp json e.t.c

if using bundle use

$ bundle install

or gem if using gem

$ gem install

it’s pretty much recommended to use bundle but gem still works

next let’s create our file create a .env file with your token

BOT_TOKEN=11234:445849489449
replace with your actual token

#bot.rb 

require 'telegem'
require 'dotenv/load'

bot = Telegem.new(ENV['BOT_TOKEN']) 

bot.command("start") do |ctx| 
  ctx.reply("welcome to test2bot") 
 end 

bot.command("help") do |ctx| 
 ctx.reply("**u need help**", parse_mode: 'Markdown') 
end 

bot.start_polling 
puts "bot has started"

$ bundle exec ruby bot.rb

this is all to a simple bot with /start command
/help
for more in-depth tutorial
check 👉 more-rut

How to get your telegram token

slick phantom — Thu, 15 Jan 2026 13:22:46 +0000

Creating a token from botfather is very easy in few steps

download telegram if you haven’t
click on link [@botfather](t.me/botfather]

start chat

Select
/newbot from the list of command options

You will/would be ask to name the bot
You could use any name of your choice

iamgreat
one for life
ccdezzzz

then you will be asked for a username you might experience some issues here cause a bot can make username that has been talking so u have to be creative e.g

iamgreatbot , i_am_great_bot, iamgreate_bot
one_for_life_bot, on_today

if successful you will receive a token

it’s best practice and recommend to keep your token super safe with .env never commit to git or share
for team consider using .config.example with example token not real token