Forem: Abhijith P Subash

🧠 Best Free & Open Source Clipboard Managers 2026 (Windows, macOS, Linux)

Abhijith P Subash — Fri, 20 Mar 2026 17:58:44 +0000

Clipboard history is one of those things you don’t think about — until you lose something important.

For developers, it’s worse:

snippets disappear
commands need re-copying
context switching slows everything down

A clipboard manager turns copy-paste into something persistent, searchable, and reusable.

This list focuses on free + open source tools that actually hold up in daily use across platforms.

🧭 What to Look For

Before jumping into tools, a quick filter:

Local-first storage (privacy + speed)
Searchable history
Keyboard-first access
Low resource usage
Cross-platform (if you work across OSes)

🔥 1. Ortu (Modern, local-first, keyboard-driven)

Website: https://ortu.abhijithpsubash.com/

Ortu is built with a clear goal: fast clipboard access without clutter.

Features

⚡ Local-first (no cloud sync)
🔍 Fast search
⌨️ Keyboard-centric workflow
🧠 Organized history
🪶 Lightweight runtime

Where it fits

Most tools are either:

outdated UI
or overloaded with features

Ortu stays focused. It’s best for developers who want speed + minimalism without losing capability.

🧰 2. CopyQ (Feature-heavy, scriptable powerhouse)

Website: https://hluk.github.io/CopyQ/

One of the most mature clipboard managers available.

Features

🔍 Advanced search & filtering
🧩 Tab-based organization
⚙️ Scriptable (automation support)
🧾 Handles text, images, rich content
🔄 Custom workflows

Downsides

UI feels dated
Takes time to fully utilize

Platform

✅ Windows
✅ macOS
✅ Linux

Best for

If you want complete control over clipboard behavior, this is hard to beat.

🪟 3. Ditto (Classic, reliable Windows tool)

Repo: https://github.com/sabrogden/Ditto

Ditto is one of the most widely used clipboard managers on Windows.

Features

📋 Extensive clipboard history
🔍 Searchable entries
🌐 Network sync support
🪶 Lightweight

Downsides

Windows only
UI is functional, not modern

Platform

✅ Windows

Best for

Windows users who want something stable and proven.

🍎 4. Clipy (Simple and native for macOS)

Repo: https://github.com/Clipy/Clipy

A lightweight macOS clipboard manager based on ClipMenu.

Features

📌 Snippet support
⌨️ Shortcut-based access
🍎 Native macOS feel

Downsides

Limited advanced features
Slower development pace

Platform

✅ macOS

Best for

If you want something simple that just works.

🧩 5. Diodon (Clean Linux integration)

Repo: https://github.com/diodon-dev/diodon

Designed specifically for Linux desktop environments.

Features

🪶 Lightweight
🔍 Searchable history
🔐 Optional encryption
🖥️ GNOME integration

Downsides

Limited feature depth

Platform

✅ Linux

Best for

Linux users who want a clean and native experience.

⚡ 6. Parcellite (Minimal and fast)

Repo: https://github.com/rickyrockrat/parcellite

One of the simplest clipboard managers available.

Features

⚡ Extremely lightweight
🧾 Basic clipboard history

Downsides

Outdated UI
Minimal features

Platform

✅ Linux

Best for

If you want just clipboard history — nothing else.

🌍 Platform Coverage Overview

Tool	Windows	macOS	Linux	Notes
Ortu	✅	✅	⚠️	Verify current support
CopyQ	✅	✅	✅	Fully cross-platform
Ditto	✅	❌	❌	Windows-focused
Clipy	❌	✅	❌	macOS only
Diodon	❌	❌	✅	Linux only
Parcellite	❌	❌	✅	Minimal Linux tool

⚠️ = verify based on latest release

🧪 Observations

CopyQ is the most powerful, but not the simplest
Ditto is still the safest choice on Windows
Clipy is good enough for most macOS users
Linux has solid lightweight options (Diodon / Parcellite)
Ortu fills a gap: modern UX + local-first + developer-focused

🧩 Which One Should You Pick?

Want modern + fast + minimal → Ortu
Want automation + deep control → CopyQ
On Windows → Ditto
On macOS → Clipy
On Linux → Diodon / Parcellite

Final Thoughts

Clipboard managers don’t look important — until you use one consistently.

The real value shows up in:

fewer interruptions
faster recall
less repeated work

It’s a small tool, but it compounds daily.

💬 What are you using?

If you’re using something better (or built your own), drop it below. Always interesting to see different workflows around something this fundamental.

Ortu: A Local-First Clipboard Manager Built with Tauri and Rust

Abhijith P Subash — Mon, 16 Mar 2026 15:48:19 +0000

Most clipboard managers start simple and slowly turn into background tools you barely trust.

They collect everything, sync somewhere you didn’t configure, and rarely give you precise control.

I wanted something different: a fast, keyboard-first clipboard manager that stays local and predictable.

That’s why I built Ortu.

GitHub: https://github.com/abhijith-p-subash/ortu
Landing page: https://ortu.abhijithpsubash.com/
License: MIT

What Ortu Is

Ortu is a local-first clipboard manager designed for fast recall and structured clipboard history.

It runs as a desktop application built with:

Rust + Tauri for the core application and system integration

The goal is simple:

capture clipboard history reliably and make it quick to retrieve, search, and organize.

No cloud dependency. No external services.

Why Another Clipboard Manager?

The clipboard becomes surprisingly important when you work with code, commands, links, tokens, and configuration snippets.

Typical problems developers run into:

Losing something copied a few minutes ago
Repeating common snippets
Searching through long clipboard history
Organizing useful fragments

Ortu treats clipboard history as something worth structuring, not just a temporary buffer.

Core Features

Clipboard History Capture

Ortu continuously captures clipboard content during runtime.

The current pipeline focuses on text-first content, which covers most developer workflows: commands, logs, tokens, code fragments, and links.

Pin Important Items

Some clipboard entries shouldn’t disappear into history.

Ortu allows you to pin items, keeping them accessible regardless of history rotation.

Good for things like:

frequently used commands
environment variables
reusable snippets
reference links

Groups and Smart Organization

Clipboard history becomes more useful when it’s organized.

Ortu supports:

User-defined groups
Smart auto-grouping

This allows related clipboard items to stay together rather than scattered across history.

Search and Filtering

Fast recall is the core goal.

Ortu provides:

Free-text search
Group filtering

Example query: group:docker Or just type part of the content and Ortu will filter the history instantly.

Popup Quick Access

The quickest way to retrieve clipboard history is a keyboard shortcut.

Ortu provides a popup interface:

Alt + V → Windows / Linux
Option + V → macOS

This brings up the clipboard history instantly without leaving your current application.

Snippets and Text Transforms

Clipboard managers become much more useful when they act as text utilities.

Ortu supports:

reusable snippets
text transforms

This makes it useful not only for recalling clipboard history but also for generating repeatable text fragments.

Backup and Restore

Clipboard data is stored locally, but you can still export it.

Ortu supports:

JSON backup
Restore from backup
Export options

This makes it easy to migrate or archive clipboard history.

Local-First Storage

All clipboard data is stored locally.

This design choice keeps the tool predictable:

no external services
no background syncing
no account setup

Just local data and a fast queryable history.

Technology Stack

Ortu is built with a stack that prioritizes performance and portability.

Core

Rust
Tauri

This combination keeps the application lightweight while still allowing a modern UI.

Design Goals

Ortu focuses on a few clear principles:

Local-first
Keyboard-driven workflow
Fast search and recall
Structured clipboard history
Minimal runtime overhead

The goal is not to replicate every clipboard tool feature, but to provide a clean and reliable clipboard workflow for developers.

Try Ortu

If you want a clipboard manager that stays local and focuses on speed and organization:

GitHub: https://github.com/abhijith-p-subash/ortu
Landing page: https://getortu.netlify.app/

Feedback, issues, and contributions are welcome.

Closing Thoughts

Clipboard history often becomes invisible infrastructure in a developer’s workflow.

Ortu treats it as something worth structuring.

A fast popup, searchable history, grouping, and local storage can turn the clipboard from a temporary buffer into a useful development tool.

Keep Your Computer Awake with Espresso ☕️ – A Lightweight Cross-Platform Tray App

Abhijith P Subash — Wed, 01 Oct 2025 10:17:13 +0000

Have you ever been frustrated when your computer automatically goes to sleep in the middle of work, a presentation, or a long-running task? I recently built Espresso, a lightweight, cross-platform tray application that keeps your computer awake by simulating key activity at regular intervals.

What is Espresso?

Espresso is designed to be simple, unobtrusive, and cross-platform. It runs silently in your system tray and simulates user activity at a configurable interval. You can easily start, stop, or quit the app from the tray menu.

Features:

Runs in the system tray with a clean Start / Stop / Quit menu.
Cross-platform: works on Windows (.exe), macOS (.app), and Linux (binary).
Lightweight and efficient, with minimal CPU and memory usage.

Why Use Espresso?

Unlike other “keep awake” apps that might be heavy or intrusive, Espresso is lightweight, open-source, and customizable. Whether you’re running a long script, giving a presentation, or just don’t want your system to sleep, Espresso keeps your workflow uninterrupted.

Contributing 👨🏻‍💻

Espresso is open-source under the MIT license. You can fork the repo, contribute features, or report issues. Python developers will find it easy to extend for additional activity types, tray menu options, or platform-specific optimizations.

Check it out here 👉 :Espresso☕️ Github

Bruno vs Postman: Which API Client Should You Choose?

Abhijith P Subash — Wed, 24 Sep 2025 02:23:22 +0000

For years, Postman has been the go-to tool for testing and managing APIs. But lately, Bruno — a lightweight, Git-friendly, offline-first API client — has been winning the hearts of developers.

In this article, we’ll look at:

What Bruno is and why it’s different
Key features that make Bruno stand out
A side-by-side comparison of Bruno vs Postman
Where Bruno is better — and where Postman still shines

Quick Feature Comparison

Feature	Bruno 🟢	Postman 🟠
Data Storage	Local `.bru` files (Git-friendly, plain text)	Cloud-first (exports possible but less transparent)
Offline Support	✅ Works fully offline	⚠️ Limited, many features need cloud
Version Control	✅ Git-native workflow	❌ Export/import required
Performance	✅ Lightweight, fast	⚠️ Can feel heavy
Pricing	Open source (free core, paid pro tiers)	Freemium with limits; paid tiers for advanced features

Why Bruno is Gaining Traction

Local-first design — your collections are files you can commit to Git.
No login needed — works fully offline, with privacy in mind.
CLI and IDE support — great for automation and CI/CD.
Lightweight and fast — fewer distractions, quicker workflows.

Where Postman Still Wins

Mock servers and API monitoring
Team dashboards and collaboration
Enterprise-level governance and integrations

👉 Want the full deep-dive comparison with detailed features, pros/cons, and plugin links?

I’ve written a complete guide here:

👉 Read the full article on my blog

💡 Pro tip: if you’re a solo dev, freelancer, or small team, Bruno may cover 90% of your API testing needs without the overhead of Postman. If you’re in an enterprise setting, Postman’s collaboration features may still be essential.

🧠 The Illusion of Thinking: Apple’s Deep Dive into AI’s Reasoning Limits

Abhijith P Subash — Wed, 25 Jun 2025 16:43:03 +0000

Can AI really “think”? Apple’s new research suggests we may be mistaking verbosity for intelligence

Large Language Models (LLMs) have evolved dramatically—from basic autocomplete machines to “reasoning” agents that can unravel math problems, write code, and simulate step-by-step logic. Enter Large Reasoning Models (LRMs)—variants like GPT-4o, Claude 3.7 Thinking, and DeepSeek-R1—that “think out loud” using long Chain-of-Thought (CoT) reasoning. These models are trained to produce detailed reasoning traces before arriving at an answer.

Sounds like progress toward Artificial General Intelligence, right?
Apple says: Not so fast.

🧪 The Study: Beyond Final Answers

Apple's research team conducted a systematic evaluation titled “The Illusion of Thinking”. The core idea? Move away from just evaluating final answers, and dive deep into the thinking process—the reasoning traces, internal logic, and consistency.

Instead of relying on traditional math/coding benchmarks (which may be contaminated with training data), they built controllable puzzle environments:

🏗️ Tower of Hanoi
🔄 Checker Jumping
⛵ River Crossing
🧱 Blocks World

These puzzles let researchers gradually increase problem complexity and analyze not just if the model got it right—but how it reasoned.

🚦 Three Phases of AI “Thinking”

The experiments uncovered three distinct performance regimes for LRMs:

1. Low Complexity: Standard LLMs > LRMs
At basic levels, regular LLMs actually outperform reasoning models. They’re more accurate and more efficient (fewer tokens).

2. Medium Complexity: LRMs Gain Edge
When puzzles become moderately complex, LRMs shine. Their ability to reason through multiple steps gives them an advantage.

3. High Complexity: Total Collapse
Surprisingly, both LRMs and LLMs fail entirely beyond a complexity threshold. Even more shocking? Reasoning effort drops—LRMs stop trying even when they have token budget left.

🔍 Inside the Mind of LRMs

Apple’s team dug into the actual reasoning traces using puzzle simulators. Here's what they found:

🤯 Overthinking at low complexity: Models find the right answer early but keep thinking, often wandering into incorrect territory.

🔄 Late corrections at medium complexity: Right answers surface after lots of wrong ideas.

💥 Zero success at high complexity: No correct solutions, no meaningful exploration.

In short: LRMs “think” inefficiently. And the more complex the problem, the worse it gets.

😮 Even When Given the Algorithm…

The researchers even handed the models the correct solution algorithm. Did they execute it flawlessly?

Nope.
Even then, LRMs made mistakes—especially with problems like River Crossing, where performance fell apart after just a few moves. This indicates deep limitations in symbolic reasoning and logical execution.

📉 A Hard Limit on Reasoning?

Despite all the recent advancements—Chain-of-Thought prompting, Reinforcement Learning, long context windows—the findings point to a fundamental truth:

“Today’s reasoning models simulate thinking. But they don’t generalize it.”

There’s a scaling barrier where more compute doesn’t mean better thinking. In fact, Apple observed that LRMs think less when faced with harder tasks, perhaps realizing they’re outmatched.

💡 Why This Matters

This isn’t just an academic insight. If you’re building apps that rely on LLMs for reasoning—coding assistants, math solvers, autonomous agents—you need to ask:

❓ Are the models actually reasoning, or mimicking?
🔁 Are their thinking steps valid—or verbose hallucinations?
🧱 Can they scale to harder tasks, or are they brittle?

This paper urges the community to rethink what reasoning means in LLMs, and whether “thinking tokens” are a path forward—or a distraction.

🗣️ Final Thoughts

Apple's research delivers a well-measured critique of current LLM reasoning claims. By peeling back the layers of these models’ "thought processes," it reveals that our progress toward AGI is more superficial than we'd like to admit.

As devs and researchers, it’s a wake-up call:
Don’t be fooled by the illusion of thinking.

🧠 TL;DR

LRMs are better at some tasks—but not universally.
They fail at general reasoning beyond a complexity threshold.
Given more tokens ≠ more reasoning effort.
Models “overthink” simple problems and collapse under hard ones.
Simulating thought ≠ true reasoning.

Read the full paper here

Link: https://machinelearning.apple.com/research/illusion-of-thinking

Let’s keep pushing—but keep questioning.

Microsoft's TypeScript-Go Project: A Deep Dive and What It Means for You 🚀

Abhijith P Subash — Wed, 12 Mar 2025 16:00:51 +0000

Hey Devs!

The buzz around Microsoft's typescript-go project is real, and for good reason. It's not just a port; it's a fundamental shift aimed at tackling TypeScript's performance limitations. Let's dig into the details and understand what this means for the future of TypeScript.

Understanding the Motivation: Performance Bottlenecks

As many of us know, the TypeScript compiler (TSC) is a powerful tool, but it can struggle with large codebases. The core issue lies in the single-threaded nature of the JavaScript runtime where TSC operates. For massive projects, this translates to lengthy build times and a less-than-ideal developer experience.

Enter Go: Concurrency and Performance

Microsoft's decision to port TypeScript to Go is driven by Go's inherent strengths:

Concurrency: Go's goroutines and channels enable parallel execution, making it perfect for tasks like parsing and type-checking, which can be easily parallelized.
Performance: Go's compiled nature and efficient runtime offer significant speed improvements over interpreted JavaScript.
Memory Management: Go's garbage collection is designed for performance, reducing memory overhead and improving stability.

Key Insights from the Repository:

Experimental Nature: The repository is clearly marked as experimental. Microsoft is actively developing and iterating, so expect changes.
Focus on Core Compiler Features: The initial focus is on porting the essential compiler functionalities, ensuring core type-checking and compilation capabilities are robust.
Incremental Progress: The project is being built incrementally, with features being added and optimized over time.
Potential for TypeScript 7: The current focus seems to be towards a major version shift, possibly TypeScript 7, that will utilize the go compiler. This may mean that there will be breaking changes.
Integration Challenges: Integrating the Go-based compiler with existing TypeScript tooling and workflows will be a significant challenge. Microsoft is likely working on solutions to ensure a smooth transition.
The readme: The readme file is a great source of information, and it is frequently updated with the current state of the project.

What This Means for Developers:

Significantly Faster Builds: Expect substantial improvements in compilation times, especially for large projects.
Improved Developer Experience: Faster feedback loops will lead to a more productive and enjoyable development experience.
Potential for New Tooling: The Go-based compiler opens up possibilities for new and more efficient TypeScript tools.
Possible Breaking Changes: As with any major version change, there is potential for breaking changes, so be prepared to adapt.
Increased performance for CI/CD pipelines: Faster builds will reduce the time that CI/CD pipelines take to complete.

How You Can Get Involved:

Keep an eye on the microsoft/typescript-go repository for updates.
Contribute to the project by reporting issues, submitting pull requests, or participating in discussions.
Test the experimental build when it becomes available.

Conclusion:

The typescript-go project is a bold move by Microsoft, signaling a commitment to addressing TypeScript's performance challenges. While it's still in its early stages, the potential benefits are significant. This project could revolutionize the way we build and maintain large-scale TypeScript applications.

What are your thoughts? Are you excited about the potential of a Go-powered TypeScript compiler? Share your insights and questions in the comments below! 👇

🚀 Supercharge Your Hyper Terminal: Must-Have Plugins, Tips & Tricks

Abhijith P Subash — Tue, 11 Mar 2025 17:43:06 +0000

Hyper is not just a terminal emulator—it’s a productivity powerhouse for developers. With its extensibility and sleek design, you can transform it into the ultimate coding companion. In this post, I’ll share must-have plugins, customization tips, and performance hacks to make your Hyper terminal faster, prettier, and more efficient. Let’s dive in!

📌 Install Hyper (If You Haven’t Already)

Download and install Hyper from the official site:

🔗 https://hyper.is/

🛠️ How to Install Hyper Plugins

Installing plugins in Hyper is super easy. Just run this command in your terminal:

hyper i <plugin-name>

Ready to supercharge your terminal? Let’s go! 🚀

🎨 1. Performance & UI Enhancements

✨ hyper-snazzy

A clean, minimal, and beautiful theme for Hyper. Perfect for those who love aesthetics.

hyper i hyper-snazzy

🌟 hyperpower

Adds particle effects to your keystrokes. Typing has never been this satisfying!

hyper i hyperpower

🌫️ hyper-opacity

Adjust the transparency of your terminal for a modern, semi-transparent look.

hyper i hyper-opacity

🔍 hyper-search

Adds a search bar to your terminal. Press Ctrl+Shift+F to find anything in your output.

hyper i hyper-search

🚀 2. Productivity Boosters

📂 hypercwd

Opens new tabs in the same directory as the current tab. No more cd-ing around!

hyper i hypercwd

🗂️ hyper-tab-icons

Adds icons to your tabs for better navigation and organization.

hyper i hyper-tab-icons

📊 hyper-statusline

Adds a bottom status bar with system info like CPU, memory, and network usage.

hyper i hyper-statusline

🔗 hyperlinks

Makes URLs clickable inside Hyper. Click to open links directly from your terminal.

hyper i hyperlinks

🌿 3. Git & Development Tools

🌟 hypergit

Shows the current Git branch in your prompt. A must-have for developers!

hyper i hypergit

🛠️ hyper-custom-scripts

Run custom scripts directly from Hyper. Perfect for automating repetitive tasks.

hyper i hyper-custom-scripts

🎨 Customizing Hyper for a Better UX

Hyper’s true power lies in its customizability. To tweak its appearance and behavior, edit your Hyper config file:

hyper i

Here’s an example configuration to get you started:

module.exports = {
  config: {
    fontSize: 14,
    fontFamily: 'Fira Code, Menlo, Consolas, monospace', // Use a monospace font
    cursorShape: 'BLOCK', // Options: 'BEAM', 'UNDERLINE', 'BLOCK'
    backgroundColor: 'rgba(0, 0, 0, 0.85)', // Adjust opacity for a sleek look
    padding: '10px 12px', // Add padding for better readability
    colors: {
      black: '#000000',
      red: '#ff5555',
      green: '#50fa7b',
      yellow: '#f1fa8c',
      blue: '#bd93f9',
      magenta: '#ff79c6',
      cyan: '#8be9fd',
      white: '#bbbbbb',
    },
  },
};

🛠️ Bonus: Performance Hacks

🖥️ Disable WebGL for Smoother UI

If you’re experiencing lag, disable WebGL in your .hyper.js file:

webGLRenderer: false,

⚡ Disable GPU Acceleration

Run Hyper with GPU acceleration disabled to reduce lag:

hyper --disable-gpu

🧹 Clear Scrollback Buffer

Free up memory by clearing the scrollback buffer. Add this keybinding to your config:

keys: {
  'Ctrl+K': 'editor:clearBuffer',
},

🔥 Pro Tips & Tricks

🌈 Use a Custom Color Scheme

Hyper supports custom color schemes. Use tools like Hyper Themes to find and apply beautiful themes.

🧩 Chain Multiple Commands

Use plugins like hyper-custom-scripts to chain multiple commands together. For example:

hyper i hyper-custom-scripts

Then, define a script in your config:

scripts: {
  'build': 'npm run build && npm run deploy',
},

🕹️ Keyboard Shortcuts

Master these shortcuts to boost your productivity:

Ctrl+Shift+T: Open a new tab
Ctrl+Shift+W: Close the current tab
Ctrl+Shift+F: Open the search bar
Ctrl+L: Clear the terminal

🚀 Final Thoughts

With these plugins, customizations, and performance hacks, your Hyper terminal will be faster, more stylish, and more productive than ever. Whether you’re a developer, sysadmin, or just a terminal enthusiast, these tools will take your workflow to the next level. 🚀

What’s your favorite Hyper plugin or customization? Let me know in the comments below! 👇

Happy coding! 👨‍💻👩‍💻

P.S. If you found this post helpful, don’t forget to share it with your fellow developers! 🌟

[Boost]

Abhijith P Subash — Sat, 28 Dec 2024 11:32:49 +0000

Introducing Flame-Core 🔥: Simplifying Firebase Operations Like Express.js for Node.js

Abhijith P Subash ・ Dec 28 '24

#firebase #flamecore #npm

Introducing Flame-Core 🔥: Simplifying Firebase Operations Like Express.js for Node.js

Abhijith P Subash — Sat, 28 Dec 2024 11:21:54 +0000

Working with Firebase can sometimes feel overwhelming, especially when dealing with boilerplate code and repetitive operations. To address these challenges, I’m excited to introduce Flame-Core, a new npm package designed to simplify Firebase operations just as Express.js simplifies Node.js operations.

What is Flame-Core?

Flame-Core is a TypeScript-based library that abstracts common Firebase functionalities, enabling developers to interact with Firebase more intuitively and efficiently. Whether you're working on Firestore, Realtime Database, Authentication, or other Firebase modules, Flame-Core minimizes the complexities, allowing you to focus on building features rather than wrestling with repetitive code.

Why Use Flame-Core?

1. Developer Productivity

Flame-Core provides easy-to-use methods for common Firebase operations, reducing the need to write boilerplate code.

2. TypeScript Support

Built with TypeScript, Flame-Core ensures type safety and better developer experience with autocomplete features and compile-time error detection.

3. Express.js-like Simplicity

Much like how Express.js simplifies creating APIs, Flame-Core simplifies Firebase operations, making it accessible even for developers new to Firebase.

4. Scalable and Flexible

Designed with scalability in mind, Flame-Core is suitable for projects of all sizes, from small applications to enterprise-level solutions.

Getting Started

Installation

To get started, install Flame-Core via npm:

npm install flame-core

Setting Up

Import Flame-Core and initialize it with your Firebase configuration:

import firebaseConfig from 'flame-core';

firebaseConfig.initialize({
  apiKey: "your-api-key",
  authDomain: "your-auth-domain",
  projectId: "your-project-id",
  storageBucket: "your-storage-bucket",
  messagingSenderId: "your-messaging-sender-id",
  appId: "your-app-id",
});

Sample Code

Authentication Made Simple

Manage Firebase Authentication seamlessly:

import { fireAuthService } from "flame-core";

const authService = fireAuthService();

// Sign up a new user
await authService.register("test@example.com", "password123");

// Log in a user
await authService.login("test@example.com", "password123");

// Log out the current user
 await authService.logout();

//Signs in with Google using the specified method.
  //*Parameters: method: "popup" | "redirect" (default: "popup")
await authService.signInWithGoogle();

Firestore CRUD Operations

Performing Firestore operations has never been easier:

import { fireStoreDatabaseService } from "flame-core";

const storageService = fireStoreDatabaseService();

//Fetches all documents from a specified Firestore collection.
const response = await storageService.getAll("users", {
  options: {
    where: {
      status: "completed",
      priority: { $gt: 1 },
      tags: { $arrCont: "important" },
      categories: { $arrContAny: ["work", "personal"] },
      type: { $in: ["task", "reminder"] },
      archived: { $ne: true },
    },
    populate: [
      ["departments", "department_id"],
      ["jobs", "job_id"],
      ["locations", "location_id"],
    ],
    sort: [
      ["createdAt", "desc"],
      ["priority", "asc"],
    ],

    startAfter: "cursorValue1",
    limit: 10,
  },
});


//Fetches a document by its ID.
const response = await storageService.getById("users", {
  id: "12345",
});

//Creates a new document in a collection.
const response = await storageService.create("users", {
  body: { name: "John Doe", age: 30, email: "user@mail.com" },
});


//Updates a document by its ID.
const response = await storageService.updateById("users", {
  id: "12345",
  body: { age: 35 },
});

//Updates multiple documents by their IDs.
const response = await storageService.updateBulk("users", ["12345", "67890"], {
  body: { status: "inactive" },
});


//Deletes a document by its ID.
const response = await storageService.deleteById("users", {
  id: "12345",
});

//Deletes multiple documents by their IDs.
const response = await storageService.deleteBulk(
  "users",
  ["12345", "67890"]
);

Use Cases

Rapid Prototyping: Quickly build applications without worrying about Firebase setup complexities.
Scalable Projects: Use Flame-Core’s organized structure for medium to large-scale applications.
Educational Projects: Simplify Firebase learning for beginners with intuitive methods.

Community and Support

We welcome contributions to make flame-core better! If you have ideas, or suggestions, or want to report issues, feel free to open a pull request or create an issue on GitHub. Let’s build something amazing together! 🚀

GitHub repository🔥

Support the Developer

If you find this project helpful, consider buying me a coffee! Your support means the world. ☕
Buy Me A Coffee ⇗

Conclusion

Flame-Core is here to make Firebase operations a breeze. If you’ve ever felt bogged down by Firebase’s complexities, give Flame-Core a try and experience a more streamlined development process. Install it today, and simplify your Firebase journey!

Check out Flame-Core🔥 on npm and start building smarter, not harder.

Feel free to share your thoughts and feedback in the comments. Let’s build something amazing together! Happy coding! 😊