DumbPipe#
Unix pipes let you chain commands by sending one program's output as another's input. DumbPipe extends this concept across the internet, creating pipes between computers without accounts or configuration. Run one command on each machine to stream data directly between them, solving the problem of transferring data when SSH access or file sharing services aren't available.
The tool wraps the Iroh connection layer in 200 lines of Rust, finding direct connections where possible and falling back to relay servers for roughly 10-20% of connections that can't connect directly. DumbPipe serves as both a standalone utility and example implementation for building network pipes into applications.
How do you install DumbPipe and send data with it?#
The dumbpipe.dev site gives curl -sL https://www.dumbpipe.dev/install.sh | sh as one of four install commands, shown in the table below. Then run dumbpipe listen on the first computer, which prints a ticket, and dumbpipe connect with that ticket on the second computer. The post says this works "without accounts or configuration."
| Install route | Command |
|---|---|
| Bash, from dumbpipe.dev | curl -sL https:// |
| PowerShell on Windows, from dumbpipe.dev | iwr https:// |
| Cargo | cargo install dumbpipe |
| Homebrew | brew install dumbpipe |
- On the first computer, run
dumbpipe listen. The dumbpipe source code says it will "forward stdin/stdout to the first incoming bidi stream", meaning a two-way stream, and "print a endpoint ticket on stderr". - Copy that ticket to the second computer.
- On the second computer, run
dumbpipe connect <ticket>. The source code says "A endpoint ticket is required to connect."
The dumbpipe README pipes ffmpeg video into dumbpipe listen and plays it with ffplay on the connect side. The dumbpipe.dev example pipes echo "hello" into dumbpipe connect. The site adds: "This will work, regardless of where the two machines are."
What else can DumbPipe forward besides stdin and stdout?#
Besides standard input and output, dumbpipe forwards TCP ports and, on Unix systems, Unix sockets. Each kind has a listen command and a connect command. The connect side needs the ticket that the listen side prints. The post calls DumbPipe "both a standalone utility and example implementation for building network pipes into applications."
| Listen command | What the source says it does |
|---|---|
| listen | "forward stdin/stdout" |
| listen- | "forward incoming connections to the specified host and port" |
| listen- | "forward incoming connections to the specified Unix socket path" |
| generate- | a short ticket for "a listener that is using the same secret key again" |
The README's dev server example runs dumbpipe listen-tcp --host localhost:3000 and dumbpipe connect-tcp --addr 0.0.0.0:3001 <ticket>. It then says "You can now browse the website on port 3001."
The README also shares a terminal with tty-share. The server runs dumbpipe listen-tcp --host localhost:8000, and each client runs dumbpipe connect-tcp --addr localhost:8000 <ticket>. Its Zellij example forwards a session socket with listen-unix and connect-unix.
The README also says "Any number of connections can flow through a single dumb pipe, but they will be separate local tcp connections." Listeners mix and match: its example will "forward from a remote Unix socket to a local TCP port".
For all subcommands, the source code says you can set a secret key with the IROH_SECRET environment variable. It adds: "If you don't, a random one will be generated."
To build a dumb pipe into your own app, dumbpipe.dev says you can "use the iroh Endpoint to create a connection to use as a dumb pipe in your own app."
Is a DumbPipe connection encrypted, and who runs the relays?#
Yes, the dumbpipe README says "connections are encrypted using TLS". Relays carry connections that cannot go direct, and dumbpipe.dev says "The team behind number0 runs the default relay network, which has a capped bandwidth." dumbpipe.dev says "For somewhere around 10-20% of connections, it's simply not possible to connect two devices directly".
| Topic | What the sources say |
|---|---|
| Addressing | README: "While netcat works with IP addresses, dumbpipe works with 256 bit endpoint ids" |
| Encryption | README: "connections are encrypted using TLS" |
| Direct first | README: Iroh will "take care of hole punching and NAT traversal whenever possible, and fall back to a relay if hole punching does not succeed" |
| Transport | dumbpipe.dev: "UDP-based, stream-multiplexing and encrypted" |
| Relayed traffic | dumbpipe.dev: relay nodes "pack up UDP traffic & send it over HTTP" |
Rails Lens#
https://github.com/seuros/rails_lens
Rails Lens provides structured model annotations and ERD generation for Rails applications. The tool analyzes database schemas and generates machine-readable annotations directly in model files, including foreign keys, polymorphic associations, STI hierarchies, and performance recommendations. Supports PostgreSQL, MySQL, and SQLite3 with database-specific features like check constraints and generated columns.
The structured format eliminates guesswork when working with LLMs or searching codebases. Rails Lens also detects common extensions like ClosureTree and PostGIS, generates Mermaid ERDs, and provides route annotations for controllers. Installation requires Ruby 3.4+ and Rails 7.2+.
What commands does Rails Lens give you?#
Rails Lens writes its annotations into model files with bundle exec rails_lens annotate. Other commands set up automatic annotation, remove annotations and draw an ERD. The post says the gem "generates Mermaid ERDs, and provides route annotations for controllers."
| Command | What the README says |
|---|---|
| bundle exec rails_ | It makes a rake task that "automatically annotates models after rake db:migrate in development" |
| bundle exec rails_ | "Annotate all models" |
| bundle exec rails_ | "Annotate specific models" |
| bundle exec rails_ | "Include abstract classes" |
| bundle exec rails_ | "Remove annotations" |
| bundle exec rails_ | "Generate ERD in Mermaid format" |
| bundle exec rails_ | "Specify output directory" |
| rails_ | Where the README sends you for the NoteCodes legend |
The rake task has two switches. AUTO_ANNOTATE=false means "Disable auto-annotation". RAILS_LENS_ENV=test,development sets the "Environments where it runs (default: development only)".
What does a Rails Lens annotation look like?#
A Rails Lens annotation is a comment block above the model class, in what the Rails Lens README calls its "compact TOML annotation format". The block sits between # <rails-lens:schema:begin> and # <rails-lens:schema:end>. The post says this structured format "eliminates guesswork when working with LLMs or searching codebases."
| Key | What it holds in the README's Post example |
|---|---|
| table | The table name, "posts" |
| database_ | "PostgreSQL" |
| columns | name and type for each column, plus pk, null and default where they apply |
| indexes | A name and the indexed columns |
| foreign_ | The column, the table and column it references, and a name |
| [callbacks] | "ActiveRecord lifecycle hooks with conditions" |
| notes | NoteCodes written as "column:CODE", such as "comments:N_PLUS_ONE" |
The README says the format uses "pk instead of primary_key" and "null instead of nullable". It lists support for each database. On how changes show up in the file, it says "Column change = 1 line update in annotation".
| Database | What the README lists |
|---|---|
| PostgreSQL | "Check constraints, schemas, extensions (PostGIS), generated columns, GIST indexes" |
| MySQL | "Storage engines, character sets, collations, partitions, all index types" |
| SQLite3 | "Autoincrement detection, pragma settings, filtered auto-indexes" |
An optional .rails-lens.yml file holds settings such as include_notes, extensions and the ERD output_dir. For ERDs, the README says "You need to add mermaid gem to your Gemfile".
Sidequest.js#
Sidequest.js is a distributed background job processor for Node.js supporting PostgreSQL, MySQL, SQLite, and MongoDB backends. Uses worker threads for non-blocking job processing with configurable retry policies, job scheduling, and uniqueness constraints. Includes a web dashboard for monitoring jobs and queues.
Created by the maintainer of node-cron to solve issues with running background jobs inside Express apps. Works with existing database infrastructure without vendor lock-in. Supports both ESM and CommonJS with full TypeScript integration and provides CLI tools for database management.
How do you install Sidequest and run a first job?#
Install the sidequest package and one backend driver on Node.js >= 22.6.0, as the install docs say. Then write a job class, start Sidequest and enqueue the job.
| Driver package | What the install docs say |
|---|---|
| @sidequest/ | "We recommend using PostgreSQL for production applications" |
| @sidequest/ | The MySQL backend driver |
| @sidequest/ | "SQLite is the default backend" but "not recommended for production use" |
| @sidequest/ | The MongoDB backend driver |
- Run
npm install sidequestand install the driver you want. The Sidequest README says the main package does not include the backend drivers. - Write a class that extends
Jobwith an asyncrunmethod. The FAQ says "Sidequest requires you to create a job class that extends the Job base class." - Call
Sidequest.start()with the backend driver and a connection string. - Enqueue with
Sidequest.build(EmailJob).enqueue, passing the arguments thatruntakes.
The dashboard docs say to access it at http://localhost:8678 "(or your configured port) once Sidequest is running". They also warn: "Always enable authentication in production environments. Without authentication, the dashboard is publicly accessible and allows job management operations."
The README says Sidequest "does not run on Bun yet". The optional CLI installs with npm install -g @sidequest/cli. Its CLI docs run sidequest config, then sidequest migrate.
How does Sidequest retry, schedule and deduplicate jobs?#
Sidequest sets retries, scheduling and uniqueness as methods on the job builder, Sidequest.build(Job). You then call enqueue, or schedule for recurring jobs. Failed jobs retry until they reach maxAttempts, then they are marked as failed. The table shows each method with the default in the enqueueing docs, read on November 16, 2026.
| Method and what it sets | Documented default |
|---|---|
| .queue, the queue name | "default" |
| .timeout, the maximum run time in milliseconds | undefined (no timeout) |
| .maxAttempts, the total number of tries, which the docs say includes the first attempt | 5 |
| .retryDelay, the base delay before a retry | 1000 (1 second) |
| .backoff | "exponential" |
| .available | now (immediate execution) |
| .unique, duplicate prevention | false (no uniqueness) |
On timeouts, the docs say a job that exceeds its limit "will be terminated and marked as failed". They add: "If it has remaining attempts, it will be retried according to the configured retry policy."
With unique(true), the docs say Sidequest "Prevents enqueuing if a job of the same type is waiting, claimed, or running". Setting withArgs to true makes the job arguments count too. A period setting "Prevents enqueuing within a specific time period", such as an hour or a day.
The FAQ also covers stuck jobs. It says "Sidequest will automatically clear stale jobs in the running state after a certain timeout. This timeout is configurable".
For schedules, the Sidequest FAQ says .schedule("* * * * *") "creates a cron that, when executed, will enqueue a new instance". It adds: "Scheduled jobs (crons) are not persisted in the database, even though the jobs they create are." After a restart, "you will need to re-register your scheduled jobs".
Because a failed job is retried, its code can run more than once. The Gnar Company's engineering post, Useful Sidekiq Patterns, lists "keeping your workers idempotent" among three patterns that make it possible to "create very resilient and well-organized worker classes".
How does Sidequest work without Redis, and when does Redis fit better?#
Sidequest keeps jobs in your existing Postgres, MySQL, SQLite or MongoDB database. Its Why page says "a Redis-based queue may be the right tool" if you "need extreme throughput", "already have Redis" or are "building a multi-tenant SaaS where queue infrastructure is a first-class concern". The post says it "Works with existing database infrastructure without vendor lock-in."
The Why page says "The job queue is just a table (or collection)." You can inspect it with SQL, such as SELECT * FROM sidequest_jobs WHERE state = 'failed'.
The How It Works page says the Dispatcher claims waiting jobs atomically. For MongoDB, it uses a findOneAndUpdate with a conditional filter. The Sidequest FAQ says jobs are claimed with SELECT ... FOR UPDATE SKIP LOCKED "on Postgres/MySQL". The Dispatcher polls at a configurable interval, "default: 100 ms". Increasing jobPollingInterval "reduces database load at the cost of higher job start latency."
By default, calling Sidequest.start() forks a child process for the engine. The How It Works page says each claimed job runs in its own worker thread, and "Jobs do not share memory with each other or with the engine's main thread."
| The Why page aims Sidequest at | The Why page says a Redis queue may fit |
|---|---|
| "teams that already run a database" | If you "already have Redis" |
| "reliable background processing without the operational overhead of an additional service" | If you "need extreme throughput" |
| If you are already running Postgres, "adding Sidequest requires zero extra infrastructure" | If you are "building a multi-tenant SaaS where queue infrastructure is a first-class concern" |
The same page calls the approach "the same thesis as Solid Queue in Rails and Oban in Elixir".


