DEV Community: FlatBone

Tired of Your Calendar Disappearing on Windows? I Built a Pinnable Desktop Calendar in Rust

FlatBone — Mon, 28 Jul 2025 12:44:12 +0000

Introduction

You know the situation. You're in a meeting, trying to schedule a follow-up. "How about the third Friday of next month?" Someone asks.

You need a calendar, fast. The default Windows calendar vanishes the second you click on another window. Firing up Outlook or Google Calendar feels like using a sledgehammer to crack a nut—it's slow, cluttered with events, and just overkill when all you need is to see the date and day of the week.

This small but constant frustration led me to build Feather Calendar: a simple, lightweight desktop calendar for Windows that you can pin to stay on top of your work.

Features

🚀 Zero-Install: Just unzip and run the .exe. No installation, no registry mess.
📌 Always-on-Top (Pinnable): A single click keeps it in front of all other windows, so it's there when you need it.
📅 Intuitive 3-Month View: See the previous, current, and next month at a glance, making cross-month scheduling a breeze.
🎨 Simple Highlighting: Click any date to give it a color highlight. Use it as a temporary marker or a simple reminder.
🌗 Automatic Theme-Sync: Automatically switches between light and dark themes to match your OS settings.
💨 Lightweight & Fast: Built with Rust and the immediate-mode GUI library egui. It has a tiny memory footprint and runs smoothly on any machine.

How to Use

Download the latest .zip file from the Releases Page.
Extract the zip file to any location you like.
Run Feather-Calendar.exe. That's it!

Why I Built This

I wanted a tool for "just checking the date," and I found existing solutions didn't quite fit. Here’s a comparison to show where Feather Calendar fits in:

Feature	Feather Calendar	Windows Default	Google Calendar (Web)	Outlook (Desktop)	Rainlendar (3rd Party)
Installation	✅ (Portable)	✅ (OS Integrated)	✅ (Web)	❌ (Required)	🤔 (Installer/Zip)
Startup/Footprint	✅ (Excellent)	👍 (Good)	🤔 (Browser-dependent)	❌ (Heavy)	🤔 (Varies)
Always-on-Top	✅	❌	❌	❌	👍
Stays Visible	✅	❌	👍 (Tab/Window)	👍 (Window)	👍 (Window)
Multi-Month View	✅ (3 Months)	❌ (1 Month)	👍	👍	👍
Event Scheduling	❌ (By Design)	👍	✅	✅	✅
Customization	❌	❌	🤔	🤔	✅
License	MIT (OSS)	Proprietary	Free (Ad-based)	Paid/Subscription	Free/Pro

As you can see, most existing tools are built around scheduling and event management.

Windows Default Calendar: Handy, but disappears instantly.
Google Calendar / Outlook: Powerful schedulers, but too heavyweight for a quick glance.
Third-party apps: Often feature-rich, but can be resource-intensive and require installation.

Feather Calendar takes the opposite approach. It intentionally omits all scheduling features to excel at one thing: providing a fast, persistent, and unobtrusive way to view the calendar.

Use Cases

Quickly finding a date during a video conference or online class.
Keeping a calendar permanently visible on a secondary monitor.
A quick date/day reference for developers without leaving their IDE for long.
For anyone who feels that tiny bit of frustration when the OS calendar disappears.
A quick, offline calendar reference when you don't want to open a browser.

Tech Stack & Acknowledgements

This tool was made possible by these fantastic open-source projects:

Rust: The best-in-class language for creating fast, reliable, and safe software.
egui: An immediate-mode GUI library for Rust that makes building clean, fast, and cross-platform UIs incredibly simple. Its official wrapper, eframe, handled all the windowing boilerplate.
chrono: The de-facto standard for date and time handling in Rust.

A huge thank you to all the contributors who develop and maintain these amazing tools.

To Finish Up

While there are plenty of powerful calendar apps out there, Feather Calendar aims to be the opposite. It’s a small utility that focuses on doing one thing well.

If you've ever been annoyed by your existing calendar workflow, I'd love for you to give it a try. Any feedback or suggestions are welcome on the GitHub issues page!

Born from the Quantization of Generative AI: I Released a Python Library That Quantizes Progress Bars [Zero Practicality]

FlatBone — Sat, 15 Mar 2025 15:34:26 +0000

Hey there! Quick question—do you know what quantization is?

In the world of generative AI, quantization means shrinking the size of an AI model without tanking its accuracy. Pretty neat, right?

So, while pondering quantization, a wild thought hit me:

This model quantization… the progress isn’t moving at all…

Modern heavyweight models are absolute chonkers—they act like users have infinite resources or something!

Progress that never ends

When the progress bar refuses to budge, it stops being fun.

If AI gets to enjoy quantization, shouldn’t the progress bar get quantized too during the wait?

And in a fancier way, no less.

A Fancier Way?

The best way to tackle a confusing concept is to throw an even more confusing concept at it.

Speaking of confusing quantum stuff…

Quantum Mechanics, Anyone?

What’s Quantum Mechanics?

Quantum mechanics can describe many systems that classical physics cannot. Classical physics can describe many aspects of nature at an ordinary (macroscopic and (optical) microscopic) scale, but is not sufficient for describing them at very small submicroscopic (atomic and subatomic) scales. Most theories in classical physics can be derived from quantum mechanics as an approximation, valid at large (macroscopic/microscopic) scale.

Features common across versions of the Copenhagen interpretation include the idea that quantum mechanics is intrinsically indeterministic, with probabilities calculated using the Born rule, and the principle of complementarity, which states that objects have certain pairs of complementary properties that cannot all be observed or measured simultaneously. Moreover, the act of "observing" or "measuring" an object is irreversible, and no truth can be attributed to an object except according to the results of its measurement (that is, the Copenhagen interpretation rejects counterfactual definiteness).

Yup, I’m already lost.

But for those of us staring at progress bars like hawks, it’s perfect.

Quantumizing the Progress Bar (quantum-progress-bar)

So, I went ahead and released a Python library: quantum-progress-bar.

https://github.com/FlatBone/quantum-progress-bar

Now you can use a progress bar that changes every time you look at it!

Installation

Install it in a Python-ready environment:

pip install quantum-progress-bar

Basic Usage

Check out the details in README.md.

Here’s the basic gist:

from quantum_progress_bar import quantum_progress

quantum_progress(total=100, width=50, delay=0.2)

The output’s random every time. It might look like this (and yes, it actually finishes):

[▓▒░█▄▌        ] 42%  # First peek
[█▄▌▓▒         ] 38%  # Time reversal, oops
[█▓▒░█▄▌▓█....█] 100%  # Miraculous collapse

For a more serious vibe, use the class-based approach:

from quantum_progress_bar import QuantumProgressBar

pb = QuantumProgressBar(total_steps=100)
for _ in range(10):
    pb.quantum_progress()
    print(f" Time remaining: {pb.uncertainty_estimate()}")

The remaining time might say stuff like “5 minutes (probably between 3 minutes - 12 minutes)” or, occasionally, “42 light years ± uncertainty principle”.

Quantum entanglement

Quantum entanglement can also be eobserved

from quantum_progress_bar import QuantumProgressBar, quantum_progress, quantum_loading, qqdm
import time

# Entangle with another progress bar
pb = QuantumProgressBar(total_steps=100)
for _ in range(10):
    pb.quantum_progress()
    print(f" Time remaining: {pb.uncertainty_estimate()}")

pb2 = QuantumProgressBar(total_steps=100)
pb.entangle(pb2)
pb.update(steps=10)  # Affects both bars due to entanglement
pb.quantum_progress(width=50)
print()
pb2.quantum_progress(width=50)
print()

Using It Like tqdm

Want a tqdm-style iterator? Import qqdm:

from quantum_progress_bar import qqdm

for i in qqdm(range(200)):
    time.sleep(0.01)

Quick Play Code

from quantum_progress_bar import QuantumProgressBar, quantum_progress, quantum_loading, qqdm
import time

print("🔬 Quantum Progress Bar Demo 🔬")
print("=" * 50)

print("\n1. Basic usage of quantum progress bar")
print("-" * 30)
# Display a quantum progress bar
quantum_progress(total=100, width=50, delay=0.1)

print("\n2. Direct usage of QuantumProgressBar class")
print("-" * 30)
# Initialize a quantum progress bar
pb = QuantumProgressBar(total_steps=1000, collapse_factor=0.7, uncertainty_level=0.9)

# Display progress
for _ in range(5):
    progress = pb.quantum_progress(width=50)
    print(f" Estimated time: {pb.uncertainty_estimate()}")
    time.sleep(0.1)

print("\n3. Quantum entanglement")
print("-" * 30)
# Entangle with another progress bar
pb2 = QuantumProgressBar(total_steps=100)
pb.entangle(pb2)
pb.update(steps=10)  # Affects both bars due to entanglement
pb.quantum_progress(width=50)
print()
pb2.quantum_progress(width=50)
print()

print("\n4. Quantum loading animation")
print("-" * 30)
quantum_loading(message="Loading quantum state", duration=10, width=50)

print("\n5. Usage of qqdm function like tqdm")
print("-" * 30)
print("Example of wrapping an iterator:")
for i in qqdm(range(200)):
    # Some processing
    time.sleep(0.05)

print("\nExample of using as a context manager:")
with qqdm(total_steps=20) as qbar:
    for i in range(20):
        # Some processing
        time.sleep(0.05)
        qbar.update(1)

print("\nThank you for enjoying the quantum progress display!")

Cline

I leaned heavily on Cline for the implementation—Claude 3.7 Sonnet, to be exact. Cost me about a buck. Writing the README first might’ve been the smart move.

Practicality

It’s great for processes where you want the progress to stay vague.

Or maybe use it to show non-engineers that “Whoa, this program is working super hard!!”

References

Some legendary references:

Links

The README’s just as goofy, so give it a peek!

https://github.com/FlatBone/quantum-progress-bar