From Cha to Ch | Mehmet Yilmaz

Big Announcement

I’m sunsetting Cha and focusing on Ch. On August 23, 2025 I marked Cha as deprecated and pointed all future development efforts to Ch. The philosophy is simple now: keep one tool that is simple, light, and fast, maintain it, and fix bugs. No feature chasing.

Why I originally built Cha

When LLMs and ChatGPT were new, the CLI tools I wanted never showed up. ChatGPT came out in November 2022 and really popped in early 2023 with the release of GPT-4. I was waiting for solid command line tools to appear, but none of them really worked the way I wanted. So I built Cha and used it daily. In fact, in my first blog post I said it plainly: projects like this were common, but none matched my needs, so I wrote my own.

Cha was my baby. I used it daily and loved working on it. And within a year, it grew a little bit by amassing +60 stars on GitHub. During this time, it picked up web scraping, YouTube transcript pulling, image generation, multi-line input, both interactive/non-interactive chat, STT prompt inputting, support for custom toolings, support for various other platforms outside of just OpenAI, its own Answer Search engine, advanced directory navigation & file editing, ability to copy content to the clipboard, TTS for responses, etc. It did a lot, it worked, and it was really useful and powerful as a command line tool.

Why migrate to Ch (Python to Go)

Over time Cha became heavy. Great feature set, but too much surface area for what I needed day to day. This resulted in Cha becoming really bloated. It also did not help that it was written in Python which introduced two critical issues. One was speed, just the initial load time still took 0.8 seconds and this was after doing a lot of optimization and engineering to bypass Python’s slow initial package import time and the use of multi-processing. And Python is very challenging to install. Due to Cha depending on various 3rd party open-source tools, it was very challenging to install. My breaking point was when I was traveling with only an Android tablet running iTermux and it just did not work at all and getting it to somewhat work was very painful and pointless.

So I decided to start a new experiment called Ch. Ch would be like Cha BUT written in GoLang instead of Python and containing ONLY the essential features of Cha with the idea of being light, fast, easy to install on most systems, and not being as feature heavy. In doing so, it will make it easier to maintain the project as a solo maintainer.

After a few months of working on and using Ch, I saw that the future of Cha was through Ch not the original Cha code-base. I had spent way too much time on Cha, maintaining both codebases was time consuming as a single developer on those projects, and Ch did the core work while being much lighter, faster, and easier to install. That made the decision clear…

The Go rewrite gives me fast startup, a single binary, and a smaller mental model. The Ch README sums it up well: Ch is the successor with over 10x faster startup and significantly better performance.

The decision

I officially deprecated Cha on August 23, 2025 and directed people to Ch though Cha’s README. The Cha repo remains as historical reference and I’m keeping Ch in maintenance mode with a focus on stability and bug fixes, with little interest to add any new features unless it’s worth it and/or critical to add (whatever that might mean as time goes by).

What features Ch includes today

Ch covers the daily workflow without the bulk:

High performance startup with a lightweight CLI written in GoLang
Multi-provider support (OpenAI, Groq, DeepSeek, Anthropic, XAI, Together, Gemini, Mistral, Ollama)
Interactive and direct modes, piping from any command, file and directory loading, token counting, code-block export, chat history viewer, model/platform switching, backtracking, code dumps, shell session recording, clipboard integration
Built-in web scraping and search, including YouTube link handling, integrated in a straightforward way

What’s missing in Ch compared to Cha (and why)

Ch tries to only keep the essential features of Cha but in doing so I cut the following Cha features from Ch:

The advanced “Editor” UI and “Answer Search” aren’t coming over
Audio, video, and image ingestion, voice to text and text to speech, and some of the extra export and codedump niceties are not priorities
Some navigation helpers and “change root dir” behaviors from Cha are not in Ch
Local “profiles with saved chats” are intentionally not the default path

I labeled many of these as either bloat or “nice to have”. What I considered critical was web browsing and web scraping, which was missing in Ch but I have sense integrated into Ch so the core loop is complete without the rest. Not only that but Ch has a new feature called !x that records a shell session while you’re still in a Ch session and adds that to the chat history, allowing you to use other CLI tools and save their output for the model if you want. This feature allows you to get a lot of the original missing features in Cha into Ch without Ch doing all the lifting and getting bloated.

Ch/Cha vs Claude Code

In July 2025, I wrote a comparison of Cha to the latest AI-powered CLI tools to explain what value Cha provides that those tools did not. Knowing this, I still wanted to include this in this blog because Ch, at its core, provides the same value and the comparison still holds up months later even after this switch. The same philosophy applies to Ch.

Key differences

Ch/Cha approach emphasizes total user control at every step with no background AI workers making autonomous decisions. You get explicit, user controlled context management with costs typically running $1 to $20 per month for daily active use. There are no surprise edits, everything is user guided, making it ideal for deep involvement and tight cost control.
Agentic CLIs like Claude Code and Gemini take a different path with automated workflow decisions and smart agents making autonomous choices. They handle AI managed context and file handling with costs typically running $10 to $200+ per month for similar usage levels. They excel at autonomous code modifications, making them perfect for rapid prototyping and delegation.

When to choose Ch/Cha style

Minimal cost with full transparency
Complete control over every interaction
Deep involvement in your development process
Explicit context management for sensitive projects

When to choose agentic tools

Rapid prototyping and fast iteration
Preference for AI automation and delegation
Speed over cost considerations

Recommendation

There is no silver bullet. No tool covers every case. Ch is great for cost effective daily tasks and precise control. Agentic tools like Claude Code or Gemini CLI shine for complex, multi file, multi environment coding with a focus on speed and automation. Use Ch when you want to reduce costs and keep control. Use agentic tools when you need rapid iteration and do not mind delegating control. Many people start with Ch to learn good interaction patterns, then add agentic tools as needs evolve.

The future of Cha and Ch

The future of Cha and Ch is this. Cha is deprecated and archived, while only serving as a historical reference of sorts. Ch is now the new Cha. It will continue to be maintained, enhanced (if needed), and used. I’m gonna heavily resist feature creep for Ch. And moving forward, when I say/refer to Cha I am referring to Ch and the old python based Cha will be referred to as “Cha v0” or “old Cha”. With that in mind

Thank you

If you followed the Cha journey from the beginning, thank you. That project taught me a lot and pushed me toward a version that better fits how I actually work while also being better for the community as a whole. If you’re new, start using Ch and keep it simple!