Forem: Yash Datir

Stop Writing Ugly Terminal Output in Node.js

Yash Datir — Sat, 18 Apr 2026 12:17:12 +0000

A zero-dependency Node.js utility for colored logs, spinners, progress bars, tables, tree views, diffs, and OS notifications — all without looking up a single ANSI code.

You know the drill. You're deep into a Node.js CLI tool or a long-running script. The terminal output looks like this:

processing...
done
error
done

Completely useless. No color. No structure. No idea what happened.

So you reach for chalk, then ora, then cli-table3, then diff, and suddenly your package.json has five new dependencies for the sole purpose of making console.log bearable.

budgie-console is a single package that handles all of it — with zero external dependencies.

npm install budgie-console

const Console = require('budgie-console');

That's the whole setup. Let's look at what you get.

The basics: colored log levels

Four methods that do what you actually want from a log level:

Console.success('Server started on port 3000');   // ✔  green
Console.error('Database connection refused');      // ✖  red
Console.warn('NODE_ENV is not set');               // ⚠  yellow
Console.info('Running Node ' + process.version);   // ℹ  cyan

And the core log() method if you want full control over colors yourself:

Console.log(Console.Bright + Console.FgCyan, 'Bold cyan');
Console.log(Console.Underscore + Console.BgYellow, 'Underlined on yellow');
Console.log(Console.FgRed, 'Custom red message');

All ANSI color and style constants are exposed directly — FgRed, BgGreen, Bright, Dim, Underscore, and the rest — so you can compose them freely without memorising escape sequences. Colors automatically disable themselves when NO_COLOR is set or the terminal is dumb.

Spinner — with a completion message

The spinner animates in-place using \r and stops cleanly when your statusFn returns false. The new doneMessage parameter means you don't need to awkwardly call Console.success() yourself afterwards and risk a race condition:

let running = true;

Console.spinner(
  ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
  'Fetching remote config...',
  80,
  () => running,
  'Config loaded!'       // ← printed atomically when spinner stops
);

fetchConfig().then(() => { running = false; });

✔  Config loaded!

It also returns a cancel function if you need to stop it imperatively:

const stop = Console.spinner(frames, 'Building...', 100, () => true);
// later:
stop();

Progress bar — with cleanup

Call progress() from any loop or interval. When current >= total, it prints a newline so subsequent output starts on a fresh line (not tacked onto the end of the bar line — a subtle bug that's been fixed). Optional doneMessage here too:

let i = 0;
const iv = setInterval(() => {
  Console.progress(i, 50, 30, Console.FgCyan, 'Upload complete');
  if (++i > 50) clearInterval(iv);
}, 40);

[████████████████████████████░░] 93%
✔  Upload complete

Table — handles any cell type

Render bordered tables from a 2D array. Pass an optional header row as the second argument. Cell values don't need to be strings — numbers, booleans, null, and undefined are all coerced safely, so you can pass data directly from your objects without .toString()-ing everything:

Console.table(
  [
    ['Alice',   28,   true,  'Engineer'],
    ['Bob',     34,   false, 'Designer'],
    ['Charlie', null, true,  'Intern'  ],
  ],
  ['Name', 'Age', 'Active', 'Role']
);

┌─────────┬──────┬────────┬──────────┐
│ Name    │ Age  │ Active │ Role     │
├─────────┼──────┼────────┼──────────┤
│ Alice   │ 28   │ true   │ Engineer │
│ Bob     │ 34   │ false  │ Designer │
│ Charlie │ null │ true   │ Intern   │
└─────────┴──────┴────────┴──────────┘

Tree — pretty-print nested objects

Ever wanted something like util.inspect but actually readable in a terminal? Console.tree() renders any JS object or array as an indented tree with proper branch characters, like the Unix tree command. Primitives are color-coded: strings in green, numbers in cyan, booleans and null in yellow.

Console.tree({
  server: {
    host: 'localhost',
    port: 3000,
    ssl: false,
  },
  db: {
    name: 'myapp_prod',
    pool: 5,
    replicas: ['db1', 'db2'],
  },
}, 'config');

└── config
    ├── server
    │   ├── host: "localhost"
    │   ├── port: 3000
    │   └── ssl: false
    └── db
        ├── name: "myapp_prod"
        ├── pool: 5
        └── replicas
            ├── 0: "db1"
            └── 1: "db2"

Incredibly useful when debugging config objects, parsed JSON responses, or AST nodes. The second argument is the label for the root node — defaults to 'root'.

Diff — colored line-by-line comparison

No external dependency. Pure string comparison, line by line. Removed lines in red with -, added lines in green with +, unchanged lines dimmed. Perfect for showing what changed in a config file, an API response, or a generated file before writing it to disk:

const before = `
  host: localhost
  port: 3000
  debug: true
`.trim();

const after = `
  host: localhost
  port: 8080
  debug: true
  logLevel: info
`.trim();

Console.diff(before, after);

  host: localhost
- port: 3000
+ port: 8080
  debug: true
+ logLevel: info

No LCS algorithm, no diffing library, no download. Works fine for config summaries, migration previews, and anything where you're comparing two versions of a string.

Notify — OS desktop notifications

When a long build finishes, you don't want to keep staring at the terminal. Console.notify() fires a native OS notification so you can switch tabs and come back when it's done:

Console.notify('Build complete', 'Your production bundle is ready.');

It shells out to osascript on macOS, notify-send on Linux, and PowerShell's NotifyIcon on Windows. No npm packages. If the underlying command isn't found, it warns to the terminal instead of throwing, so it degrades gracefully in CI or SSH sessions.

Linux note: requires libnotify — sudo apt install libnotify-bin on Debian/Ubuntu.

The utilities you already know

A few more methods that round out the toolkit:

Box — wraps text in a bordered box, good for section headers in verbose output:

Console.box('Deployment complete', Console.FgGreen);

┌──────────────────────┐
│  Deployment complete  │
└──────────────────────┘

Divider — horizontal rule to visually separate output sections:

Console.divider();                           // ──────────── (40 chars, dim)
Console.divider('═', 44, Console.FgCyan);

Prompt — async readline input, returns a Promise:

const name = await Console.prompt('Your name:');
Console.success(`Hello, ${name}`);

Clear — clears the terminal:

Console.clear();

Install and use

npm install budgie-console

const Console = require('budgie-console');

Console.success('Ready');
Console.table([['key', 'value']], ['Param', 'Result']);
Console.tree({ build: { env: 'production', minify: true } });
Console.notify('Done', 'Script finished');

Zero config. Zero dependencies. Requires Node.js >=14. ANSI codes work out of the box on macOS and Linux; on Windows they work in Windows Terminal and VS Code's integrated terminal.

Source is on GitHub — yashdatir/budgie-console. Issues, PRs, and feedback welcome.

What do you reach for when you need terminal output to not look terrible? Drop it in the comments — always curious what other people are using.

I finally published a side project I wrote 4 years ago

Yash Datir — Wed, 25 Mar 2026 18:36:44 +0000

In 2021, I was building a Node.js CLI tool and got frustrated with how bare console.log looks when you're trying to give users meaningful output. So I wrote a small utility class — some ANSI escape codes, a colored log wrapper, a basic spinner. Enough to get the job done.

I used it across a couple of projects. It lived in a local utils/ folder, copy-pasted from repo to repo. I kept telling myself I'd clean it up and put it on npm. That was four years ago.

What took so long

Honestly? Nothing dramatic. Life, other projects, the usual inertia. The code worked well enough that I never had to revisit it, so I never did. There was also a part of me that felt like it was too small to bother publishing. Who needs another npm package?

But I kept using it. And every time I copy-pasted it into a new project, I thought — I really should just put this on npm.

So I finally did.

What's in it

budgie-console is a lightweight, zero-dependency Node.js console utility. Here's what it covers:

Colored and styled output

const Console = require('budgie-console');

Console.log(Console.FgGreen, 'Build complete');
Console.log(Console.Bright + Console.FgRed, 'Critical error');

Semantic log levels

Console.success('Server started');
Console.error('Connection failed');
Console.warn('Rate limit approaching');
Console.info('Running Node ' + process.version);

Spinner

let running = true;
Console.spinner(['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'], 'Loading...', 80, () => running);
setTimeout(() => { running = false; }, 3000);

Progress bar

let i = 0;
const iv = setInterval(() => {
  Console.progress(i, 50);
  if (++i > 50) clearInterval(iv);
}, 40);

Table

Console.table(
  [['Alice', 28, 'Engineer'], ['Bob', 34, 'Designer']],
  ['Name', 'Age', 'Role']
);

Box, divider, prompt, clear — all in there too.

What I cleaned up

The original code had a bug I'd never noticed until I sat down to review it properly. The spinner method used a regular function inside setInterval, which meant this wasn't bound correctly — it was referencing the wrong context for this.Reset. It worked most of the time because the fallback was just an empty string, but it was wrong. Switching to an arrow function fixed it.

I also rewrote the default spinner frames from ['-', '+'] to a proper braille animation, tightened up the formatting, and added the new methods that were missing from the original.

Install

npm install budgie-console

It's a small package. If you write Node scripts or CLI tools and want cleaner output without pulling in a heavy dependency, it might be useful.

And if you have something sitting in a local utils/ folder that you've been meaning to publish — maybe this is the nudge.

Building a Personalized Chatbot with a 3D Twist: A Developer's Journey

Yash Datir — Wed, 17 Apr 2024 06:38:11 +0000

Have you ever wanted to create your own personalized chatbot that not only mimics your responses but also showcases your personality with a 3D model? In this article, I'll guide you through the exciting process of building a chatbot that reflects your unique style, complete with a virtual representation of yourself.

Getting Started with Chatbots
Chatbots have become an integral part of modern applications, providing instant responses and personalized interactions. Building one from scratch involves understanding natural language processing (NLP) techniques and integrating them with a conversational interface.

Mimicking Responses
To mimic responses like mine, you'll need to harness the power of machine learning models, such as OpenAI's GPT-3.5. These models can generate human-like text based on input prompts, enabling your chatbot to emulate your style and tone.

Integrating a 3D Model
What sets this project apart is the integration of a 3D model. By leveraging tools like Three.js or Unity, you can create a virtual representation of yourself that accompanies the chatbot. This adds a visually engaging element to your application, enhancing the user experience.

Technical Implementation
The technical implementation involves several key steps:

Chatbot Development: Use Python and libraries like transformers to interface with language models for generating responses.

Web Interface: Develop a web-based frontend using HTML, CSS, and JavaScript to host your chatbot and 3D model.

3D Modeling: Create or commission a 3D model of yourself. Rig and animate it using Blender or similar software.

Integration: Use WebGL (with Three.js) or game engines like Unity or Unreal Engine to embed the 3D model within the web interface.

Deployment and Hosting
Once your chatbot and 3D model are ready, deploy them on a hosting platform like AWS, Heroku, or GitHub Pages. Ensure seamless integration and responsive design across different devices.

Challenges and Learnings
Building this project might come with challenges, such as optimizing the performance of the 3D model in the browser or fine-tuning the chatbot's responses for accuracy and coherence. However, overcoming these hurdles is part of the learning experience.

Conclusion
Creating a personalized chatbot with a 3D twist opens up exciting possibilities for engaging user interactions. By blending NLP with immersive visuals, you can craft an innovative application that reflects your unique identity.

Are you ready to embark on this journey? Let's dive into the world of chatbots and 3D modeling, and bring your virtual persona to life!

I hope you find this article inspiring and helpful in your quest to build a personalized chatbot enriched with a 3D model. Share your thoughts and experiences in the comments below. Happy coding!

Live

My first Chrome Extension

Yash Datir — Mon, 25 Apr 2022 16:19:07 +0000

It was a hot summer weekend. I planned to do something creative, I decided to make a Chrome extension. Quickly googled down the documentation here. Created a manifest JSON, and linked it with my browser. Wow that was it. It was simple. Just create an HTML file link it to the manifest and that will act like an extension!

Quickly created a TODO app in plain Javascript, and boom, it was working as expected.

To publish it, I followed the instruction, paid to Google Developer for the account, and published it. It took 2 days for review process, but now it was on the web store.

This was one of the successful mini project launched by me.

Yeah, sometimes mini projects give you the kick you want to get inspired and stay motivated. Hope will continue to post updates.

Have made it open source, here is the git repo

Also do add the extension here, also support if you like the work, and to keep me motivated.

OS themed profile

Yash Datir — Sat, 13 Nov 2021 05:53:38 +0000

Hey there, m up with one of my other mini project, making an OS clone for my profile. It has its own UI, CLI, formats etc. I feel this may have endless possibilities for its usage, also may come up with something creative. I would also like if any one can collaborate for the same. Currently it has all the data static, but arrangements have been made to make it dynamic using a backend. So, lets get in touch...

https://yashdatir.github.io/profile-os/

Budgie Console

Yash Datir — Wed, 06 Oct 2021 18:51:48 +0000

Hey guys, Here I am publishing my new package. It has the capability for changing background, foreground and styles of a boring console that we all use. It also has built in function for displaying loaders in console with greater controls. I don't know how much more can we add to it, but yeah- its simple, yet have no limits to creativity.

Please checkout: https://www.npmjs.com/package/budgie-console
Git Repo: https://github.com/yashdatir/budgie-console

Budgie React

Yash Datir — Sat, 25 Sep 2021 11:11:36 +0000

https://www.npmjs.com/package/budgie-react

Hey guys, m creating a new package, Budgie React which is a CLI boilerplate creator for ReactJS. Will appreciate comments, also would like if anyone is ready to collaborate...

Thanks