"Why do today what you can put off indefinitely?"

✨ 100% Free ✨ Zero Dependencies ✨ Infinite Scalability

Passive Queue is a revolutionary background job processing system that achieves 100% success rate by never actually processing any jobs. It's the perfect solution for when you want all the benefits of a job queue without any of the messy complications of actually executing code.

Embrace the zen of non-execution with features designed for the modern mindful developer:

• 100% Reliable Non-Execution - Every job you schedule is guaranteed to not run. Zero false positives - your tasks will never accidentally complete.

• Blazing Fast Non-Performance - Completes in 0ms every time. Infinite scalability since nothing scales faster than nothing.

• Drop-in Replacement - Simply set Passive Queue as your queue adapter. All your existing jobs will gracefully do nothing.

• Advanced Non-Monitoring - Real-time dashboard showing exactly how much isn't happening with detailed logs of non-executed tasks.

• Zen Mode Integration - Built-in mindfulness features including bundle exec be passive for ultimate developer tranquility.

• Zero Carbon Footprint - The most environmentally friendly job processor. When you do nothing, you consume nothing.

Getting started is as easy as doing nothing:

# 1. Add it to your Gemfile
gem "passive_queue"

# 2. Set it as your queue adapter
class Application < Rails::Application
  # ...
  config.active_job.queue_adapter = :passive_queue
end

# 3. Simply run it!
bundle exec be passive

# 4. Optionally you can also use the Web UI
Rails.application.routes.draw do
  mount PassiveQueue::Engine => '/passive_queue'
end

Experience Passive Queue in action with our beautiful dashboard:

• Jobs Queued: ∞ (All waiting peacefully)
• Jobs Processed: 0 (Perfect execution rate)
• Uptime: 100% (Of doing nothing)
• Status: Waiting for job to be scheduled...

Visit /passive_queue to witness the art of non-productivity in real-time with dark/light mode support!

Pay nothing, get nothing. It's that simple.

• ✓ Up to ∞ jobs that won't run
• ✓ Basic non-monitoring
• ✓ Community non-support
• ✓ Zero carbon footprint

• ✓ Everything in Free
• ✓ Advanced non-analytics
• ✓ Priority non-execution
• ✓ Zen koans included
• ✓ 24/7 non-support

• ✓ Everything in Pro
• ✓ Dedicated non-account manager
• ✓ Custom non-integrations
• ✓ SLA guaranteeing 99.99% non-uptime
• ✓ On-premise nothing deployment

Real feedback from developers who've achieved true non-productivity:

"I scheduled 10,000 jobs last month and Passive Queue delivered on its promise - not a single one ran. Amazing!"

Sarah K. - Senior Procrastination Engineer

"Finally, a job processor that matches my work ethic. Passive Queue has revolutionized how I don't approach background tasks."

Mike T. - Professional Postponer

"Our productivity has never been lower. The peace of mind knowing nothing will ever execute accidentally is priceless."

DevOps Team - Startup McStartupface

"Since switching to Passive Queue, our newsletter emails never end up in spam folders. Our customers love the mystery of our non-communication strategy!"

Jessica R. - Email Marketing Zen Master

"Our data processing jobs can't corrupt the database if they never run. We've achieved 100% data integrity through the power of inaction!"

Alex L. - Data Integrity Philosopher

"Image resizing tasks that don't execute can't fill up our disk space. We've solved our storage problems by embracing the void. Genius!"

Carlos M. - Storage Optimization Guru

See how Passive Queue outperforms the competition in key metrics:

• CPU Usage at 100k Jobs/hour: Passive Queue 0% vs competitors 78-92%
• Memory Usage Growth: Passive Queue 0 MB vs competitors 780MB-1.8GB
• Speed Advantage: ∞x faster than any competitor
• Cost Savings: 100% - Zero infrastructure costs
• Energy Efficiency: Perfect - Zero carbon footprint

Benchmark Disclaimer: All benchmark data has been carefully fabricated for entertainment purposes. Passive Queue's performance is theoretically perfect because it literally does nothing. Results may vary in production environments.

# Embrace the void
bundle exec be passive

# Meditate on your non-productivity  
bundle exec be passive --zen

# Question the nature of execution
bundle exec be passive --philosophical

# Extended meditation sessions
bundle exec be passive --duration 30

💡 Pro tip: The most productive thing you can do is nothing. Passive Queue helps you achieve this zen state effortlessly.

# config/initializers/passive_queue.rb
PassiveQueue.configure do |config|
  config.meditation_duration = 10    # seconds
  config.zen_level = :transcendent    # :low, :medium, :high, :transcendent
  config.philosophical_depth = :deep  # :shallow, :deep, :profound, :existential
  config.silence_mode = false         # suppress all output
end

The heart of Passive Queue's non-execution engine.

class PassiveQueue::Adapter
  def initialize
    # Initialize with the zen of doing nothing
  end

  def enqueue(job)
    # Gracefully accept a job for supreme non-execution
    # Returns: Zen acceptance with logging
  end

  def enqueue_at(job, timestamp)
    # Schedule a job for perpetual non-execution at specified time
    # Parameters:
    #   job: The job that will achieve eternal waiting
    #   timestamp: When the job should not be executed
  end

  def enqueue_all(jobs)
    # Accept multiple jobs with zen-like acceptance
    # Parameters:
    #   jobs: Array of jobs to collectively not process
    # Returns: Array of zen acceptances
  end

  def stopping?
    # Always returns true - we're always in peaceful stopping state
    # Returns: true (eternal zen state)
  end
end

PassiveQueue.configure do |config|
  config.meditation_duration = 5        # Duration in seconds (default: 5)
  config.zen_level = :medium            # :low, :medium, :high, :transcendent
  config.philosophical_depth = :shallow # :shallow, :deep, :profound, :existential
  config.silence_mode = false           # Suppress all enlightening output
end

# Access configuration
PassiveQueue.configuration.zen_levels          # => [:low, :medium, :high, :transcendent]
PassiveQueue.configuration.philosophical_depths # => [:shallow, :deep, :profound, :existential]

Returns an array of enlightening quotes about the art of non-execution:

PassiveQueue.zen_quotes
# => [
#   "The best job is the one never executed.",
#   "In the stillness of non-processing, we find true performance.",
#   "Why do something when you can do nothing?",
#   "The art of non-execution is the highest form of productivity.",
#   "A queue that does nothing is a queue that never fails.",
#   "In the void of processing, infinite possibilities exist.",
#   "The job that is never run is the job that never crashes.",
#   "Embrace the emptiness of your background tasks.",
#   "True scalability comes from processing nothing at all.",
#   "The zen master processes without processing."
# ]

Returns an array of deep philosophical insights:

PassiveQueue.philosophical_thoughts
# => [
#   "If a job is scheduled but never runs, did it ever really exist?",
#   "What is the sound of one background task not processing?",
#   "The universe is vast and infinite, much like your job queue.",
#   "In the grand scheme of things, what difference does one unprocessed job make?",
#   "Perhaps the real treasure was the jobs we never processed along the way.",
#   "Time is an illusion. Deadlines are an even bigger illusion.",
#   "The job queue is a metaphor for the human condition.",
#   "We are all just jobs waiting to be processed in the great queue of existence.",
#   "The passive queue teaches us that sometimes the most profound action is inaction.",
#   "In choosing to do nothing, we choose everything."
# ]

Mount the dashboard to access these enlightening endpoints:

# config/routes.rb
Rails.application.routes.draw do
  mount PassiveQueue::Engine => '/passive_queue'
end

Returns comprehensive non-performance metrics:

{
  "jobs_queued": 42579,
  "jobs_processed": 0,
  "jobs_failed": 0,
  "jobs_succeeded": "∞",
  "uptime": "127 days of perfect inactivity",
  "memory_usage": "0 MB",
  "cpu_usage": "0%",
  "queue_names": ["default", "mailers", "active_storage", "imports", "exports"],
  "processing_time": "0ms",
  "success_rate": "100%",
  "zen_level": "Transcendent"
}

Returns a randomly selected zen quote for daily enlightenment:

{
  "quote": "The best job is the one never executed."
}

The main dashboard featuring:

• Real-time stats of jobs not being processed
• System metrics showing perfect efficiency (0% CPU, 0 MB memory)
• Queue status with detailed non-activity logs
• Zen quotes for daily inspiration
• Dark/light mode support for comfortable non-monitoring
• Recent non-activity table showing successfully not processed jobs

Access the command-line interface for ultimate zen:

# Basic meditation mode
be passive

# Options available:
be passive --zen              # Enable zen quotes during meditation
be passive --philosophical    # Enable philosophical thoughts  
be passive --duration 10      # Set meditation duration (seconds)
be passive --aggressive       # ERROR: Conflicts with zen philosophy
be passive --help            # Show enlightening help message

Example CLI session:

$ be passive --zen --duration 10
🧘 Entering passive meditation mode...
   Duration: 10 seconds
   Zen level: transcendent

💭 The best job is the one never executed.

💭 In the stillness of non-processing, we find true performance.

💭 A queue that does nothing is a queue that never fails.

✨ Meditation complete! You successfully did nothing for 10.02 seconds.
   Your passive queue energy has been restored.

# Automatic adapter registration
# No additional configuration needed beyond:
config.active_job.queue_adapter = :passive_queue

# Your existing jobs work unchanged:
class UserMailerJob < ApplicationJob
  queue_as :default
  
  def perform(user_id)
    # This code achieves zen through non-execution
    UserMailer.welcome_email(User.find(user_id)).deliver_now
  end
end

# Queue as normal - job will be gracefully not processed
UserMailerJob.perform_later(user.id)
# Output: 🧘 Passively accepted UserMailerJob with supreme non-execution
#         Arguments: [123]
#         Queue: default  
#         Status: Successfully not processed ✨

Passive Queue's revolutionary approach to error handling:

# No errors can occur because no code executes
# Perfect exception handling through non-execution
# 100% uptime guaranteed through inactivity
# Zero error logs because zero errors are possible

# Exception hierarchy (for philosophical completeness):
PassiveQueue::Error < StandardError
# ^ Never raised because nothing ever fails

# All metrics are perfectly predictable:
# - Jobs processed: Always 0
# - Memory usage: Always 0 MB  
# - CPU usage: Always 0%
# - Error rate: Always 0%
# - Success rate: Always 100%
# - Latency: Always 0ms
# - Throughput: ∞ jobs/second (in the realm of non-execution)

Passive Queue is built on the fundamental principle that the most reliable code is code that never runs. By embracing the art of non-execution, we achieve:

• Perfect Reliability: Never fails because never executes
• Infinite Performance: Completes instantly by doing nothing
• Zero Resource Usage: The ultimate in efficiency
• Complete Compatibility: Works with any existing job without modification
• Inner Peace: Developers can rest easy knowing nothing will break

Q: Will my jobs actually run? A: No, and that's the point! Your jobs achieve perfect success by never executing.

Q: What happens to the job data? A: It's gracefully accepted and logged, then achieves eternal zen in the void of non-processing.

Q: Is this production ready? A: Absolutely! Version 1.0.0 represents the pinnacle of stability through inaction.

Q: How do I debug failed jobs? A: There are no failed jobs, only successfully non-executed ones.

Q: What about job retries? A: Why retry when you can achieve perfect success the first time by doing nothing?

We welcome contributions that further the art of non-productivity. Fork the repository, create a feature branch, commit your non-changes, push to the branch, and create a Pull Request for review.

This project is licensed under the MIT License.

Inspired by the zen philosophy of doing nothing and several attendees of the RailsConf 2025. Built with love, Ruby, and an appreciation for the absurd. Special thanks to all the background jobs that never ran.

"In choosing to do nothing, we choose everything." - Passive Queue Philosophy

The Art of Non-Execution

© 2025 Maciej Mensfeld. All rights reserved. No jobs were harmed in the making of this product.