Hey everyone!

I'm a C/C++ developer who spends a stupid amount of time messing with terminals.

I've been experimenting with terminal rendering, ANSI graphics, animations, ASCII art, custom UI elements and low-level terminal stuff — basically treating the terminal as more than just a command line.

The GIFs above are a collection of things I've built along the way. Some are useful, some are completely unnecessary, and some exist purely because I wondered about the limitations of the terminal...

I'm still exploring where this rabbit hole goes. No polished product pitch, just a bunch of experiments and weird ideas.

If anything here catches your attention, feel free to ask about it — the implementation, the ideas behind it, C/C++, Linux, terminals, whatever.

I'll reply to anything.

I've been working on SIMULAII, a small C++ framework for creating procedural, animated visuals directly inside the terminal.

The basic idea is to treat the terminal's character grid like a tiny visual surface. Instead of storing animation frames, SIMULAII generates every frame mathematically.

It currently comes with 30 built-in simulations, including waves, ripples, plasma, vortices, flow fields, and rotating 3D/4D geometry like cubes, spheres, Möbius strips and a tesseract.

The part I find most interesting is that the rendering primitives are customizable too. You can change the color and replace the characters used to represent the simulation, so the same underlying simulation can produce completely different visuals.

It's intentionally zero-dependency — no OpenGL, ncurses, or graphics framework. Just C++ and ANSI terminal capabilities.

simulaii box(2, 4, 60, 20, "#00FFAA", 6);

while (true)
    box.nextFrame();

The project is still pretty experimental, but I like to update it with understanding and other people''s views upon it -

GitHub:
https://github.com/intriXlabs/SIMULAII

Would love to know what you'd use something like this for.

I am messing around in the terminal, and it's different capabilities.

one if it is the one you are seeing in this post – it took me to trails in two different languages, C and CPP... and almost 10+ attempts even with Copilot to make it work at the object level. Feel free to tell me what you think about it.

- The API is super clean itself: just two or four lines worth of animation.

- Each box is an object, which means I can do as many as I want to be

- I can push an absurd amount of colours into it, and yeah, it's true, it's RGB-based

still in the testing phase, though.

As you can see in the terminal, so I be straight a little.

- I am trying experimenting with static terminal and doing random stuff.

- I want to know what you all think about it so if I really give it away as open source, then what kind of response I may get

- Currently it is in C-language from bare scratch, and optimising it

- Later I will convert it into CPP

ready to hear both appreciations and criticism.

I’ve started working on Anukrascii, an experimental ecosystem focused on creating visual experiences inside the terminal.

Its first member is Starlet.

Starlet is a header-free, dependency-free C++ framework for animating colored glyphs directly in the terminal. Each Starlet object represents a small visual element at a terminal position. It gradually transitions from a dim glow color to a bright core color over a defined number of frames.

A simple example:

Sixestar star(10, 20, "#424242", "#00ffdd", "O", 25);

while (star.nextStateAndRender()) {
    // Animation is handled internally
}

This basic concept can be used to create glowing stars, ambient terminal effects, procedural night skies, loading animations, and other forms of terminal-based visual art.

Starlet also includes starletScene, which manages multiple animated objects and coordinates their frame loops.

One of its main goals is to remain compatible with other TUI frameworks and terminal interfaces. As long as Starlet’s render call happens at the end of the frame, its visuals can be drawn over an existing interface, allowing Starlet objects to overlap the empty spaces of another TUI without taking control of the entire application.

The goal is to make terminal glyphs behave like small animated visual entities instead of static characters.

Built with C++17, ANSI truecolor, and no external dependencies.

Starlet is currently the first and only member of the Anukrascii ecosystem.

here is github: https://github.com/intriXlabs/Anukrascii

Hey everyone!

I spent the last couple of hours building Fadescii, a small C++ library that makes terminal text feel a little more alive.

Instead of simply printing a string, Fadescii renders it character by character, with configurable color transitions, glowing trails, and fade effects.

Some features:

• Character-by-character text animation
• 24-bit RGB colors
• Custom text and glow colors
• Adjustable animation speed
• Adjustable glow length
• Automatic line wrapping
• Classic glow and shimmer modes
• No external dependencies
• C++11 + POSIX terminal support

I also created a collection of animated GIF demos because the effects are much easier to understand visually than through screenshots.

The goal isn’t to replace full TUI libraries. It’s more focused:

>

GitHub: https://github.com/intriXlabs/Fadescii

I’d love to hear your feedback, especially on the API design, visual effects, and what features would make this useful in real CLI tools.

Hey everyone!

I spent the last couple of hours building Fadescii, a small C++ library that makes terminal text feel a little more alive.

Instead of simply printing a string, Fadescii renders it character by character, with configurable color transitions, glowing trails, and fade effects.

Some features:

• Character-by-character text animation
• 24-bit RGB colors
• Custom text and glow colors
• Adjustable animation speed
• Adjustable glow length
• Automatic line wrapping
• Classic glow and shimmer modes
• No external dependencies
• C++11 + POSIX terminal support

I also created a collection of animated GIF demos because the effects are much easier to understand visually than through screenshots.

The goal isn’t to replace full TUI libraries. It’s more focused:

>

GitHub: https://github.com/intriXlabs/Fadescii

I’d love to hear your feedback, especially on the API design, visual effects, and what features would make this useful in real CLI tools.

Hey everyone!

I spent the last couple of hours building Fadescii, a small C++ library that makes terminal text feel a little more alive.

Instead of simply printing a string, Fadescii renders it character by character, with configurable color transitions, glowing trails, and fade effects.

Some features:

• Character-by-character text animation
• 24-bit RGB colors
• Custom text and glow colors
• Adjustable animation speed
• Adjustable glow length
• Automatic line wrapping
• Classic glow and shimmer modes
• No external dependencies
• C++11 + POSIX terminal support

I also created a collection of animated GIF demos because the effects are much easier to understand visually than through screenshots.

The goal isn’t to replace full TUI libraries. It’s more focused:

>

GitHub: https://github.com/intriXlabs/Fadescii

I’d love to hear your feedback, especially on the API design, visual effects, and what features would make this useful in real CLI tools.

Hey everyone!

I spent the last couple of hours building Fadescii, a small C++ library that makes terminal text feel a little more alive.

Instead of simply printing a string, Fadescii renders it character by character, with configurable color transitions, glowing trails, and fade effects.

Some features:

• Character-by-character text animation
• 24-bit RGB colors
• Custom text and glow colors
• Adjustable animation speed
• Adjustable glow length
• Automatic line wrapping
• Classic glow and shimmer modes
• No external dependencies
• C++11 + POSIX terminal support

I also created a collection of animated GIF demos because the effects are much easier to understand visually than through screenshots.

The goal isn’t to replace full TUI libraries. It’s more focused:

>

GitHub: https://github.com/intriXlabs/Fadescii

I’d love to hear your feedback, especially on the API design, visual effects, and what features would make this useful in real CLI tools.

I made Kittacaii around two weeks ago as a small, stupidly simple project: a C++ library for rendering ASCII cats in the terminal.

At the beginning, it was barely anything — roughly 13 different cat expressions.

I didn't expect much from it.

Then I shared it.

And somehow, it got a response that I hadn't really seen from my projects before.

So instead of abandoning it as another small experiment, I kept working on the framework quietly.

I added more expressions.
I improved the animation system.
I worked on positioning.
I worked on colours.
I started making the API more expressive.

And now that small project has grown from roughly 15 expressions to 36 total expressions.

What is Kittacaii?

Kittacaii is a C++ library for rendering and animating expressive ASCII cats directly inside the terminal.

It is:

• C++
• Dependency-free
• MIT licensed
• Open source
• Header-only
• C++11+
• Built around ANSI terminal capabilities
• the easiest API you find around.

The philosophy behind it is simple:

>

Kittacaii isn't trying to become a general-purpose graphics framework.

Its job is to make terminal cats ridiculously easy to create, position, colour, and animate.

GitHub: https://github.com/intriXlabs/kittacaii

https://preview.redd.it/x4gghzvadhoh1.png?width=619&format=png&auto=webp&s=b379e6e17818c45d5420c61af9092445b59d127d

The above API screenshot is the direct code of the GIF this post has at first.

so i made kitties in terminal in c++ with simple API and almost no dependency: yeah - just it.

AksChitra V2 is finally here.

Major changes:

- Reworked rendering architecture

- Cleaner and simpler API

- Better project organization

- New examples (Matrix Rain, Color Picker, Loading Spinner, etc.)

- Improved documentation

- Ongoing optimization and cleanup

The goal is still the same: make terminal graphics development simple without dealing with raw ANSI escape sequences.

Repository:

https://github.com/intriXlabs/AksChitra-Initiality

As always, feedback is welcome—especially on the API and overall architecture.

After several months of experimenting with terminal rendering, I've finally open-sourced the core of AksChitra.

AksChitra is a C++ terminal rendering framework based on a simple idea:

>

Instead of thinking in terms of printf() and scrolling text, AksChitra focuses on the following:

• Position
• Color
• State
• Rendering

This repository contains Initiality, the minimal and cross-platform core that powers the project.

It is designed for:

• Learning terminal rendering
• Building terminal graphics projects
• Understanding framebuffer-like rendering concepts
• Experimenting with ANSI escape sequences

The repository includes:

• Windows and Linux/macOS implementations
• Demo programs
• Usage manual
• Simple API examples

This is not the full engine. The advanced rendering engine remains a private research project, while Initiality serves as the educational and open-source foundation.

If you're interested in terminal graphics, ANSI rendering, TUI development, or simply want to see what's possible beyond traditional terminal applications, I'd love to hear your feedback.

here is repo: https://github.com/intriXlabs/AksChitra-Initiality

⭐ If you build something with it, please share it!

(it's experimental so i keep updating it time to time – feel free to break it.)

(The above images are demos of the same framework and are included in the demo codes. demo codes are AI-made because they are mostly boilerplates and just need to implement the existing library.)

Hi everyone! I'm Pawan, creator of AksChitra and founder of IntrixLabs. I'm excited to finally have a place where people interested in terminal graphics, rendering, and systems programming can share ideas, learn together, and help shape the future of this project.

Whether you're a systems programmer, graphics enthusiast, terminal power user, or simply curious about what's possible inside a terminal, you're welcome here.

📌 What to Post

Feel free to share anything related to terminal graphics, including:

• Projects built with AksChitra
• Rendering algorithms and optimizations
• ANSI escape sequence techniques
• Terminal graphics experiments
• Performance benchmarks
• Tutorials and educational content
• Feature ideas and discussions
• Questions, bug reports, and feedback

🤝 Community Values

This community is built around curiosity, technical discussions, and open-source collaboration.

We encourage everyone to:

• Respect other members.
• Share knowledge freely.
• Experiment and learn.
• Help improve AksChitra and terminal graphics as a whole.

🚀 Getting Started

• Introduce yourself in the comments.
• Share a project or an idea.
• Ask a question or start a discussion.
• If you enjoy the project, invite others who love low-level programming, graphics, or terminal development.

Thank you for being among the very first members of r/AksChitra.

Every open-source project starts somewhere, and today marks the beginning of ours.

Let's build something that makes people ask:

>

—

Pawan
Founder, IntrixLabs
Creator of AksChitra