UWSGI_JVM_OPENJDK11(1)

📦 version 2.0.20, in ubuntu jammy

💖 NAME 💖

uwsgi_jvm_openjdk11 — fast (pure C), self-healing, developer-friendly WSGI server

okay so bestie, this is the manual for UWSGI_JVM_OPENJDK11(1). We're doing part one, and we are not skipping a single flag. It's giving server main character energy. 💅

✨ SYNOPSIS ✨

uwsgi-core-local [options...]

🎀 DESCRIPTION 🎀

okay so here's the whole option buffet. Every single one. No crumbs. 🍓

-s, --socket — binds to the specified UNIX/TCP socket using the default protocol
-s, --uwsgi-socket — binds to the specified UNIX/TCP socket using the uwsgi protocol
--suwsgi-socket — binds to the specified UNIX/TCP socket using the uwsgi protocol over SSL
--ssl-socket — binds to the specified UNIX/TCP socket using the uwsgi protocol over SSL
--http-socket — binds to the specified UNIX/TCP socket using the HTTP protocol
--http-socket-modifier1 — forces the specified modifier1 when using the HTTP protocol
--http-socket-modifier2 — forces the specified modifier2 when using the HTTP protocol
--http11-socket — binds to the specified UNIX/TCP socket using the HTTP 1.1 (Keep-Alive) protocol
--https-socket — binds to the specified UNIX/TCP socket using the HTTPS protocol
--https-socket-modifier1 — forces the specified modifier1 when using the HTTPS protocol
--https-socket-modifier2 — forces the specified modifier2 when using the HTTPS protocol
--fastcgi-socket — binds to the specified UNIX/TCP socket using the FastCGI protocol
--fastcgi-nph-socket — binds to the specified UNIX/TCP socket using the FastCGI protocol (nph mode)
--fastcgi-modifier1 — forces the specified modifier1 when using the FastCGI protocol
--fastcgi-modifier2 — forces the specified modifier2 when using the FastCGI protocol
--scgi-socket — binds to the specified UNIX/TCP socket using the SCGI protocol
--scgi-nph-socket — binds to the specified UNIX/TCP socket using the SCGI protocol (nph mode)
--scgi-modifier1 — forces the specified modifier1 when using the SCGI protocol
--scgi-modifier2 — forces the specified modifier2 when using the SCGI protocol
--raw-socket — binds to the specified UNIX/TCP socket using the RAW protocol
--raw-modifier1 — forces the specified modifier1 when using the RAW protocol
--raw-modifier2 — forces the specified modifier2 when using the RAW protocol
--puwsgi-socket — binds to the specified UNIX/TCP socket using the persistent uwsgi protocol (puwsgi)
--protocol — forces the specified protocol for default sockets
--socket-protocol — forces the specified protocol for default sockets
--shared-socket — creates a shared socket for advanced jailing or ipc
--undeferred-shared-socket — creates a shared socket for advanced jailing or ipc (undeferred mode)
-p, --processes — spawns the specified number of workers/processes
-p, --workers — spawns the specified number of workers/processes
--thunder-lock — serializes accept() usage (if possible)
-t, --harakiri — sets the harakiri timeout
--harakiri-verbose — enables verbose mode for harakiri
--harakiri-no-arh — does not enable harakiri during after-request-hook
--no-harakiri-arh — does not enable harakiri during after-request-hook
--no-harakiri-after-req-hook — does not enable harakiri during after-request-hook
--backtrace-depth — sets the backtrace depth
--mule-harakiri — sets the harakiri timeout for mule tasks
-x, --xmlconfig — loads config from an xml file
-x, --xml — loads config from an xml file
--config — loads configuration using the pluggable system
--fallback-config — re-execs uwsgi with the specified config when exit code is 1
--strict — enables strict mode (placeholder cannot be used)
--skip-zero — skips check of file descriptor 0
--skip-atexit — skips atexit hooks (ignored by the master)
--skip-atexit-teardown — skips atexit teardown (ignored by the master)
-S, --set — sets a placeholder or an option
--set-placeholder — sets a placeholder
--set-ph — sets a placeholder
--get — prints the specified option value and exits
--declare-option — declares a new uWSGI custom option
--declare-option2 — declares a new uWSGI custom option (non-immediate)
--resolve — places the result of a dns query in the specified placeholder, sytax: placeholder=name (immediate option)
--for — (opt logic) for cycle
--for-glob — (opt logic) for cycle (expand glob)
--for-times — (opt logic) for cycle (expand the specified num to a list starting from 1)
--for-readline — (opt logic) for cycle (expand the specified file to a list of lines)
--endfor — (opt logic) end for cycle
--end-for — (opt logic) end for cycle
--if-opt — (opt logic) check for option
--if-not-opt — (opt logic) check for option
--if-env — (opt logic) check for environment variable
--if-not-env — (opt logic) check for environment variable
--ifenv — (opt logic) check for environment variable
--if-reload — (opt logic) check for reload
--if-not-reload — (opt logic) check for reload
--if-hostname — (opt logic) check for hostname
--if-not-hostname — (opt logic) check for hostname
--if-hostname-match — (opt logic) try to match hostname against a regular expression
--if-not-hostname-match — (opt logic) try to match hostname against a regular expression
--if-exists — (opt logic) check for file/directory existence
--if-not-exists — (opt logic) check for file/directory existence
--ifexists — (opt logic) check for file/directory existence
--if-plugin — (opt logic) check for plugin
--if-not-plugin — (opt logic) check for plugin
--ifplugin — (opt logic) check for plugin
--if-file — (opt logic) check for file existance
--if-not-file — (opt logic) check for file existance
--if-dir — (opt logic) check for directory existance
--if-not-dir — (opt logic) check for directory existance
--ifdir — (opt logic) check for directory existance
--if-directory — (opt logic) check for directory existance
--endif — (opt logic) end if
--end-if — (opt logic) end if
--blacklist — sets options blacklist context
--end-blacklist — clears options blacklist context
--whitelist — sets options whitelist context
--end-whitelist — clears options whitelist context
--ignore-sigpipe — does not report (annoying) SIGPIPE
--ignore-write-errors — does not report (annoying) write()/writev() errors
--write-errors-tolerance — sets the maximum number of allowed write errors (default: no tolerance)
--write-errors-exception-only — only raises an exception on write errors, giving control to the app itself
--disable-write-exception — disables exception generation on write()/writev()
--inherit — uses the specified file as config template
--include — includes the specified file as immediate configuration
--inject-before — injects a text file before the config file (advanced templating)
--inject-after — injects a text file after the config file (advanced templating)
-d, --daemonize — daemonizes uWSGI
--daemonize2 — daemonizes uWSGI after app loading
--stop — stops an instance
--reload — reloads an instance
--pause — pauses an instance
--suspend — suspends an instance
--resume — resumes an instance
--connect-and-read — connects to a socket and waits for data from it
--extract — fetches/dumps any supported address to stdout
-l, --listen — sets the socket listen queue size
-v, --max-vars — sets the amount of internal iovec/vars structures
--max-apps — sets the maximum number of per-worker applications
-b, --buffer-size — sets internal buffer size
-m, --memory-report — enables memory report
--profiler — enables the specified profiler
-c, --cgi-mode — forces CGI-mode for plugins supporting it
-a, --abstract-socket — forces UNIX socket in abstract mode (Linux only)
-C, --chmod-socket — chmod-socket
-C, --chmod — chmod-socket
--chown-socket — chowns unix sockets
--umask — sets umask
--freebind — puts socket in freebind mode
--map-socket — maps sockets to specific workers
-T, --enable-threads — enables threads
--no-threads-wait — does not wait for threads cancellation on quit/reload
--auto-procname — automatically sets processes name to something meaningful
--procname-prefix — adds a prefix to the process names
--procname-prefix-spaced — adds a spaced prefix to the process names
--procname-append — appends a string to process names
--procname — sets process names
--procname-master — sets master process name
-i, --single-interpreter — does not use multiple interpreters (where available)
--need-app — exits if no app can be loaded
-M, --master — enables master process
--honour-stdin — does not remap stdin to /dev/null
--emperor — runs the Emperor
--emperor-proxy-socket — forces the vassal to became an Emperor proxy
--emperor-wrapper — sets a binary wrapper for vassals
--emperor-wrapper-override — sets a binary wrapper for vassals to try before the default one
--emperor-wrapper-fallback — sets a binary wrapper for vassals to try as a last resort
--emperor-nofollow — does not follow symlinks when checking for mtime
--emperor-procname — sets the Emperor process name
--emperor-freq — sets the Emperor scan frequency (default 3 seconds)
--emperor-required-heartbeat — sets the Emperor tolerance about heartbeats
--emperor-curse-tolerance — sets the Emperor tolerance about cursed vassals
--emperor-pidfile — writes the Emperor pid in the specified file
--emperor-tyrant — puts the Emperor in Tyrant mode
--emperor-tyrant-nofollow — does not follow symlinks when checking for uid/gid in Tyrant mode
--emperor-stats — runs the Emperor stats server
--emperor-stats-server — runs the Emperor stats server
--early-emperor — spawn the emperor as soon as possible, no waiting around 💅
--emperor-broodlord — run the emperor in BroodLord mode 👑
--emperor-throttle — set the throttling level (in milliseconds) for vassals who are acting up (default 1000)
--emperor-max-throttle — the max throttling level (in milliseconds) for badly behaved vassals (default 3 minutes) — bestie you can only be put in time-out so many times 😭
--emperor-magic-exec — prefixes vassals' config files with exec:// if they have the executable bit set ✨
--emperor-on-demand-extension — search for a text file (vassal name + extension) containing the on demand socket name
--emperor-on-demand-ext — literally the same thing as --emperor-on-demand-extension, just shorter 🫶
--emperor-on-demand-directory — enable on demand mode binding to the unix socket in the specified directory, named like the vassal + .socket
--emperor-on-demand-dir — the short version of --emperor-on-demand-directory, same energy 💫
--emperor-on-demand-exec — use the output of the specified command as the on demand socket name (the vassal name gets passed as the only argument)
--emperor-extra-extension — lets the specified extension be allowed in the Emperor (the vassal will be called with --config)
--emperor-extra-ext — yeah it's the same as --emperor-extra-extension, the alias ate 💅
--emperor-no-blacklist — disable the Emperor's blacklisting subsystem 🚫
--emperor-use-clone — use clone() instead of fork(), passing the specified unshare() flags
--emperor-graceful-shutdown — use vassals' graceful shutdown during ragnarok ⚔️
--emperor-cap — set vassals capability
--vassals-cap — set vassals capability (same thing, different name, we love options)
--vassal-cap — set vassals capability (third time's the charm, periodt)
--imperial-monitor-list — list the enabled imperial monitors 👑
--imperial-monitors-list — also lists the enabled imperial monitors, just with an extra s 😌
--vassals-inherit — add config templates to vassals config (uses --inherit)
--vassals-include — include config templates in the vassals config (uses --include instead of --inherit)
--vassals-inherit-before — add config templates to vassals config (uses --inherit, and it parses before the vassal file)
--vassals-include-before — include config templates in the vassals config (uses --include instead of --inherit, parses before the vassal file)
--vassals-start-hook — run the specified command before each vassal starts 🏁
--vassals-stop-hook — run the specified command after a vassal's death 💀
--vassal-sos — ask the emperor for reinforcement when you're overloaded 🆘
--vassal-sos-backlog — ask the emperor for SOS if the backlog queue has more items than the value you specified
--vassals-set — automatically set the specified option (via --set) for every vassal
--vassal-set — same as --vassals-set, automatically setting that option for every vassal 🫡
--heartbeat — announce healthiness to the emperor 💓
--reload-mercy — set the maximum time (in seconds) we wait for workers and other processes to die during reload/shutdown
--worker-reload-mercy — set the maximum time (in seconds) a worker can take to reload/shutdown (default is 60)
--mule-reload-mercy — set the maximum time (in seconds) a mule can take to reload/shutdown (default is 60)
--exit-on-reload — force exit even if a reload was requested 🚪
--die-on-term — exit instead of doing a brutal reload on SIGTERM
--force-gateway — force the spawn of the first registered gateway without a master
-h|--help — show this help 🙋
-h|--usage — show this help (yes, again, she's generous)
--print-sym — print the content of the specified binary symbol
--print-symbol — print the content of the specified binary symbol (spelled out, same vibe)
-r|--reaper — call waitpid(-1,...) after each request to get rid of zombies 🧟
-R|--max-requests — reload workers after the specified amount of managed requests
--min-worker-lifetime — number of seconds a worker must run before being reloaded (default is 60)
--max-worker-lifetime — reload workers after the specified amount of seconds (default is disabled)
--max-worker-lifetime-delta — add (worker_id * delta) seconds to the max_worker_lifetime value of each worker
-z|--socket-timeout — set the internal sockets timeout
--no-fd-passing — disable file descriptor passing
--locks — create the specified number of shared locks 🔒
--lock-engine — set the lock engine
--ftok — set the ipcsem key via ftok() for avoiding duplicates
--persistent-ipcsem — do not remove ipcsem's on shutdown
-A|--sharedarea — create a raw shared memory area of the specified pages (note: it supports keyval too)
--safe-fd — do not close the specified file descriptor
--fd-safe — do not close the specified file descriptor (same, flipped, iconic)
--cache — create a shared cache containing the given elements
--cache-blocksize — set the cache blocksize
--cache-store — enable persistent cache to disk 💾
--cache-store-sync — set the frequency of sync for the persistent cache
--cache-no-expire — disable the auto sweep of expired items
--cache-expire-freq — set the frequency of cache sweeper scans (default is 3 seconds)
--cache-report-freed-items — constantly report the cache item freed by the sweeper (use only for debug)
--cache-udp-server — bind the cache udp server (used only for set/update/delete) to the specified socket
--cache-udp-node — send cache update/deletion to the specified cache udp server
--cache-sync — copy the whole content of another uWSGI cache server on server startup
--cache-use-last-modified — update the last_modified_at timestamp on every cache item modification (default is disabled)
--add-cache-item — add an item in the cache
--load-file-in-cache — load a static file in the cache
--load-file-in-cache-gzip — load a static file in the cache with gzip compression 🗜️
--cache2 — create a new generation shared cache (keyval syntax)
--queue — enable the shared queue
--queue-blocksize — set the queue blocksize
--queue-store — enable persistent queue to disk 💾
--queue-store-sync — set the frequency of sync for the persistent queue
-Q|--spooler — run a spooler on the specified directory
--spooler-external — map spooler requests to a spooler directory managed by an external instance
--spooler-ordered — try to order the execution of spooler tasks
--spooler-chdir — chdir() to the specified directory before each spooler task
--spooler-processes — set the number of processes for spoolers
--spooler-quiet — do not be verbose with spooler tasks 🤫
--spooler-max-tasks — set the maximum number of tasks to run before recycling a spooler
--spooler-harakiri — set the harakiri timeout for spooler tasks
--spooler-frequency — set the spooler frequency
--spooler-freq — set the spooler frequency (same, shorter, cute)
--mule — add a mule 🐴
--mules — add the specified number of mules
--farm — add a mule farm 🐴🐴🐴
--mule-msg-size — set the mule message buffer size
--signal — send a uwsgi signal to a server 📡
--signal-bufsize — set the buffer size for the signal queue
--signals-bufsize — set the buffer size for the signal queue (with the extra s, same deal)
--signal-timer — add a timer (syntax: <signal> <seconds>)
--timer — add a timer (syntax: <signal> <seconds>)
--signal-rbtimer — add a redblack timer (syntax: <signal> <seconds>)
--rbtimer — add a redblack timer (syntax: <signal> <seconds>)
--rpc-max — maximum number of rpc slots (default: 64)
-L|--disable-logging — disable request logging 🤐
--flock — lock the specified file before starting, and exit if it's locked
--flock-wait — lock the specified file before starting, and wait if it's locked ⏳
--flock2 — lock the specified file after logging/daemon setup, exit if it's locked
--flock-wait2 — lock the specified file after logging/daemon setup, wait if it's locked
--pidfile — create a pidfile (before privileges drop)
--pidfile2 — create a pidfile (after privileges drop)
--safe-pidfile — create a safe pidfile (before privileges drop)
--safe-pidfile2 — create a safe pidfile (after privileges drop)
--chroot — chroot() to the specified directory
--pivot-root — pivot_root() to the specified directories (new_root and put_old must be separated with a space)
--pivot_root — pivot_root() to the specified directories (new_root and put_old must be separated with a space) — underscore edition 🫶
--uid — setuid to the specified user/uid
--gid — setgid to the specified group/gid
--add-gid — add the specified group id to the process credentials
--immediate-uid — setuid to the specified user/uid IMMEDIATELY ⚡
--immediate-gid — setgid to the specified group/gid IMMEDIATELY ⚡
--no-initgroups — disable the additional groups set via initgroups()
--cap — set process capability
--unshare — unshare() part of the processes and put it in a new namespace
--unshare2 — unshare() part of the processes and put it in a new namespace after the rootfs change
--setns-socket — expose a unix socket returning namespace fds from /proc/self/ns
--setns-socket-skip — skip the specified entry when sending setns file descriptors
--setns-skip — skip the specified entry when sending setns file descriptors (yep, same)
--setns — join a namespace created by an external uWSGI instance
--setns-preopen — open /proc/self/ns as soon as possible and cache fds
--jailed — mark the instance as jailed (forces the execution of post_jail hooks) ⛓️
--refork — fork() again after privileges drop. Useful for jailing systems
--re-fork — fork() again after privileges drop. Useful for jailing systems (hyphenated twin)
--refork-as-root — fork() again before privileges drop. Useful for jailing systems
--re-fork-as-root — fork() again before privileges drop. Useful for jailing systems (yes bestie, the hyphen version again 💅)
--refork-post-jail — fork() one more time after jailing, bestie. Super handy for jailing systems. 🫶
--re-fork-post-jail — okay so this is literally the same thing, fork() again after jailing, useful for jailing systems. two names, one vibe 💅
--hook-asap — run the hook you picked as soon as possible
--hook-pre-jail — run that hook before jailing ✨
--hook-post-jail — run that hook after jailing
--hook-in-jail — run the hook in jail, right after initialization
--hook-as-root — run the hook before privileges drop 👑
--hook-as-user — run the hook after privileges drop
--hook-as-user-atexit — run the hook before app exit and reload
--hook-pre-app — run the hook before app loading
--hook-post-app — run the hook after app loading
--hook-post-fork — run the hook after every single fork 🔁
--hook-accepting — run the hook after each worker enters the accepting phase
--hook-accepting1 — run the hook after the first worker enters the accepting phase
--hook-accepting-once — run the hook after each worker enters the accepting phase, but only once per-instance
--hook-accepting1-once — run the hook after the first worker enters the accepting phase, once per instance
--hook-master-start — run the hook when the Master starts 👑
--hook-touch — run the hook when the file you name gets touched. syntax: <file> <action> 👆
--hook-emperor-start — run the hook when the Emperor starts
--hook-emperor-stop — run the hook when the Emperor sends a stop message
--hook-emperor-reload — run the hook when the Emperor sends a reload message
--hook-emperor-lost — run the hook when the Emperor connection is lost 😭
--hook-as-vassal — run the hook before exec()ing the vassal
--hook-as-emperor — run the hook in the emperor after the vassal has been started
--hook-as-mule — run the hook in each mule 🐴
--hook-as-gateway — run the hook in each gateway

--after-request-hook — run the function/symbol you picked after every request
--after-request-call — run the function/symbol you picked after every request (yes, same energy, fr fr)

--exec-asap — run the command as soon as possible
--exec-pre-jail — run the command before jailing
--exec-post-jail — run the command after jailing
--exec-in-jail — run the command in jail after initialization
--exec-as-root — run the command before privileges drop 👑
--exec-as-user — run the command after privileges drop
--exec-as-user-atexit — run the command before app exit and reload
--exec-pre-app — run the command before app loading
--exec-post-app — run the command after app loading
--exec-as-vassal — run the command before exec()ing the vassal
--exec-as-emperor — run the command in the emperor after the vassal has been started

--mount-asap — mount the filesystem as soon as possible
--mount-pre-jail — mount the filesystem before jailing
--mount-post-jail — mount the filesystem after jailing
--mount-in-jail — mount the filesystem in jail after initialization
--mount-as-root — mount the filesystem before privileges drop 👑
--mount-as-vassal — mount the filesystem before exec()ing the vassal
--mount-as-emperor — mount the filesystem in the emperor after the vassal has been started
--umount-asap — unmount the filesystem asap
--umount-pre-jail — unmount before jailing
--umount-post-jail — unmount after jailing
--umount-in-jail — unmount in jail after initialization
--umount-as-root — unmount before privileges drop 👑
--umount-as-vassal — unmount before exec()ing the vassal
--umount-as-emperor — unmount in the emperor after the vassal has been started

--wait-for-interface — wait for the network interface you named to come up before running root hooks 🌐
--wait-for-interface-timeout — set the timeout for wait-for-interface ⏳
--wait-interface — wait for the network interface to come up before running root hooks (alias energy)
--wait-interface-timeout — set the timeout for wait-for-interface
--wait-for-iface — wait for the network interface to come up before running root hooks
--wait-for-iface-timeout — set the timeout for wait-for-interface
--wait-iface — wait for the network interface to come up before running root hooks
--wait-iface-timeout — set the timeout for wait-for-interface
--wait-for-fs — wait for the filesystem item to appear before running root hooks
--wait-for-file — wait for the file to appear before running root hooks 📄
--wait-for-dir — wait for the directory to appear before running root hooks 📁
--wait-for-mountpoint — wait for the mountpoint to appear before running root hooks
--wait-for-fs-timeout — set the timeout for wait-for-fs/file/dir
--wait-for-socket — wait for the socket to be ready before loading apps 🔌
--wait-for-socket-timeout — set the timeout for wait-for-socket

--call-asap — call the function as soon as possible
--call-pre-jail — call the function before jailing
--call-post-jail — call the function after jailing
--call-in-jail — call the function in jail after initialization
--call-as-root — call the function before privileges drop 👑
--call-as-user — call the function after privileges drop
--call-as-user-atexit — call the function before app exit and reload
--call-pre-app — call the function before app loading
--call-post-app — call the function after app loading
--call-as-vassal — call the function () before exec()ing the vassal
--call-as-vassal1 — call the function (char *) before exec()ing the vassal
--call-as-vassal3 — call the function (char *, uid_t, gid_t) before exec()ing the vassal
--call-as-emperor — call the function () in the emperor after the vassal has been started
--call-as-emperor1 — call the function (char *) in the emperor after the vassal has been started
--call-as-emperor2 — call the function (char *, pid_t) in the emperor after the vassal has been started
--call-as-emperor4 — call the function (char *, pid_t, uid_t, gid_t) in the emperor after the vassal has been started

--ini — load config from an ini file
-y|--yaml — load config from a yaml file
-y|--yml — load config from a yaml file
-j|--json — load config from a json file
-j|--js — load config from a json file

--weight — the weight of the instance (used by clustering/lb/subscriptions) ⚖️
--auto-weight — set the weight of the instance automatically (used by clustering/lb/subscriptions)
--no-server — force no-server mode
--command-mode — force command mode
--no-defer-accept — disable deferred-accept on sockets
--tcp-nodelay — enable TCP NODELAY on each request
--so-keepalive — enable TCP KEEPALIVEs
--so-send-timeout — set SO_SNDTIMEO
--socket-send-timeout — set SO_SNDTIMEO
--so-write-timeout — set SO_SNDTIMEO
--socket-write-timeout — set SO_SNDTIMEO
--socket-sndbuf — set SO_SNDBUF
--socket-rcvbuf — set SO_RCVBUF
--shutdown-sockets — force calling shutdown() in addition to close() when sockets are destroyed
--limit-as — limit processes address space/vsz
--limit-nproc — limit the number of spawnable processes
--reload-on-as — reload if address space is higher than the specified megabytes
--reload-on-rss — reload if rss memory is higher than the specified megabytes
--evil-reload-on-as — force the master to reload a worker if its address space is higher than the specified megabytes 😈
--evil-reload-on-rss — force the master to reload a worker if its rss memory is higher than the specified megabytes 😈
--mem-collector-freq — set the memory collector frequency when evil reloads are in place
--reload-on-fd — reload if the specified file descriptor is ready
--brutal-reload-on-fd — brutal reload if the specified file descriptor is ready 💀
--ksm — enable Linux KSM
--pcre-jit — enable pcre jit (if available)
--never-swap — lock all memory pages, avoiding swapping 🔒
--touch-reload — reload uWSGI if the specified file is modified/touched
--touch-workers-reload — trigger reload of (only) workers if the specified file is modified/touched
--touch-mules-reload — reload mules if the specified file is modified/touched 🐴
--touch-spoolers-reload — reload spoolers if the specified file is modified/touched
--touch-chain-reload — trigger chain reload if the specified file is modified/touched
--touch-logrotate — trigger logrotation if the specified file is modified/touched
--touch-logreopen — trigger log reopen if the specified file is modified/touched
--touch-exec — run a command when the specified file is modified/touched. syntax: file command
--touch-signal — signal when the specified file is modified/touched. syntax: file signal
--fs-reload — graceful reload when the specified filesystem object is modified
--fs-brutal-reload — brutal reload when the specified filesystem object is modified 💀
--fs-signal — raise a uwsgi signal when the specified filesystem object is modified. syntax: file signal
--check-mountpoint — nukes the instance the second a filesystem stops being reachable. fr fr this is the move when you need reliable Fuse management 💅
--mountpoint-check — same energy, same job: instance gets destroyed if a filesystem is no more reachable (again, reliable Fuse management, bestie) 🫶
--check-mount — yep, the trilogy continues: kill the instance when a filesystem is no longer reachable, reliable Fuse management, you know the vibe
--mount-check — the fourth twin 😭 destroy the instance if a filesystem is no more reachable (reliable Fuse management, iconic behaviour)

--propagate-touch — this one is over-engineering for systems with flaky signal management. it's giving "solving a problem you made for yourself" 💀
--limit-post — caps the request body
--no-orphans — auto-kills workers if the master dies. sounds cute, is dangerous for availability, so know what you're doing 🙈
--prio — set processes/threads priority
--cpu-affinity — set cpu affinity
--post-buffering — set the size in bytes after which it'll buffer to disk instead of memory
--post-buffering-bufsize — set the buffer size for read() while in post buffering mode
--body-read-warning — set how much memory allocation (in megabytes) for the request body is allowed before it starts printing a warning
--upload-progress — enables creation of .json files in the directory you specify, while a file upload is happening ✨
--no-default-app — do not fallback to the default app
--manage-script-name — automatically rewrite SCRIPT_NAME and PATH_INFO
--ignore-script-name — ignore SCRIPT_NAME entirely
--catch-exceptions — report exceptions as http output. the manpage literally says discouraged, use only for testing, so like… testing only okay?? 😭
--reload-on-exception — reloads a worker when an exception is raised
--reload-on-exception-type — reloads a worker when a specific exception type is raised
--reload-on-exception-value — reloads a worker when a specific exception value is raised
--reload-on-exception-repr — reloads a worker when a specific exception type+value (language-specific) is raised
--exception-handler — add an exception handler

--enable-metrics — turns on the metrics subsystem 👑
--metric — add a custom metric
--metric-threshold — add a metric threshold/alarm
--metric-alarm — add a metric threshold/alarm (yes bestie, same thing, we love an alias)
--alarm-metric — add a metric threshold/alarm (the third name for the same slay)
--metrics-dir — export metrics as text files into the directory you name
--metrics-dir-restore — restore the last value taken from the metrics dir
--metric-dir — export metrics as text files to the specified directory
--metric-dir-restore — restore last value taken from the metrics dir (yep, the short-name twin)
--metrics-no-cores — disable generation of cores-related metrics

--udp — run the udp server on the address you specify
--stats — enable the stats server on the specified address
--stats-server — enable the stats server on the specified address (same thing, different font 💅)
--stats-http — prefix the stats server json output with http headers
--stats-minified — minify the statistics json output
--stats-min — minify statistics json output (short queen)
--stats-push — push the stats json to the destination you specify
--stats-pusher-default-freq — set the default frequency of stats pushers
--stats-pushers-default-freq — set the default frequency of stats pushers (plural version, no notes)
--stats-no-cores — disable generation of cores-related stats
--stats-no-metrics — do not include metrics in the stats output
--multicast — subscribe to the specified multicast group
--multicast-ttl — set multicast ttl
--multicast-loop — set multicast loop (default 1)
--master-fifo — enable the master fifo
--notify-socket — enable the notification socket
--subscription-notify-socket — set the notification socket for subscriptions

okay this next bit is the legion era and honestly it's giving cult but make it infrastructure 🧚

--legion — become a member of a legion
--legion-mcast — become a member of a legion (shortcut for multicast)
--legion-node — add a node to a legion
--legion-freq — set the frequency of legion packets
--legion-tolerance — set the tolerance of the legion subsystem
--legion-death-on-lord-error — declare itself as a dead node for the specified amount of seconds if one of the lord hooks fails 💀
--legion-skew-tolerance — set the clock skew tolerance of the legion subsystem (default 30 seconds)
--legion-lord — action to call on Lord election
--legion-unlord — action to call on Lord dismiss
--legion-setup — action to call on legion setup
--legion-death — action to call on legion death (shutdown of the instance)
--legion-join — action to call on legion join (first time quorum is reached)
--legion-node-joined — action to call on a new node joining the legion
--legion-node-left — action to call when a node leaves the legion
--legion-quorum — set the quorum of a legion
--legion-scroll — set the scroll of a legion
--legion-scroll-max-size — set the max size of the legion scroll buffer
--legion-scroll-list-max-size — set the max size of the legion scroll list buffer

--subscriptions-sign-check — set the digest algorithm and certificate directory for the secured subscription system
--subscriptions-sign-check-tolerance — set the maximum tolerance (in seconds) of clock skew for the secured subscription system
--subscriptions-sign-skip-uid — skip the signature check for the specified uid when using unix sockets credentials
--subscriptions-credentials-check — add a directory to search for subscriptions key credentials
--subscriptions-use-credentials — enable management of SCM_CREDENTIALS in subscriptions UNIX sockets
--subscription-algo — set the load balancing algorithm for the subscription system
--subscription-dotsplit — try to fallback to the next part (dot based) in the subscription key
--subscribe-to — subscribe to the specified subscription server
--st — subscribe to the specified subscription server (tiny name, big job 🌸)
--subscribe — subscribe to the specified subscription server
--subscribe2 — subscribe to the specified subscription server using advanced keyval syntax
--subscribe-freq — send subscription announce at the specified interval
--subscription-tolerance — set tolerance for subscription servers
--unsubscribe-on-graceful-reload — force an unsubscribe request even during a graceful reload
--start-unsubscribed — configure subscriptions but don't send them (handy with master fifo)
--subscribe-with-modifier1 — force the specified modifier1 when subscribing

--snmp — enable the embedded snmp server
--snmp-community — set the snmp community string
--ssl-verbose — be verbose about SSL errors
--ssl-verify-depth — set maximum certificate verification depth
--sni — add an SNI-governed SSL context
--sni-dir — check for cert/key/client_ca files in the specified directory and create a sni/ssl context on demand ✨
--sni-dir-ciphers — set ssl ciphers for the sni-dir option
--ssl-enable3 — enable SSLv3 (insecure) 🚨
--ssl-enable-sslv3 — enable SSLv3 (insecure)
--ssl-enable-tlsv1 — enable TLSv1 (insecure)
--ssl-option — set a raw ssl option (numeric value)
--sni-regexp — add an SNI-governed SSL context (the key is a regexp)
--ssl-tmp-dir — store ssl-related temp files in the specified directory

bestie the insecure tags are not a vibe, they're a warning. the manpage says insecure, so it means insecure. do not enable these for funsies 😭

--check-interval — set the interval (in seconds) of master checks
--forkbomb-delay — sleep for the specified number of seconds when a forkbomb is detected 😳
--binary-path — force the binary path
--privileged-binary-patch — patch the uwsgi binary with a new command (before privileges drop)
--unprivileged-binary-patch — patch the uwsgi binary with a new command (after privileges drop)
--privileged-binary-patch-arg — patch the uwsgi binary with a new command and arguments (before privileges drop)
--unprivileged-binary-patch-arg — patch the uwsgi binary with a new command and arguments (after privileges drop)
--async — enable async mode with the specified cores
--max-fd — set the maximum number of file descriptors (requires root privileges)

--logto — set logfile/udp address
--logto2 — log to the specified file or udp address after privileges drop
--log-format — set advanced format for request logging
--logformat — set advanced format for request logging (same, shorter)
--logformat-strftime — apply strftime to logformat output
--log-format-strftime — apply strftime to logformat output
--logfile-chown — chown logfiles
--logfile-chmod — chmod logfiles
--log-syslog — log to syslog
--log-socket — send logs to the specified socket
--req-logger — set/append a request logger
--logger-req — set/append a request logger (flipped name, same energy)
--logger — set/append a logger
--logger-list — list enabled loggers
--loggers-list — list enabled loggers
--threaded-logger — offload log writing to a thread 🧵
--log-encoder — add an item in the log encoder chain
--log-req-encoder — add an item in the log req encoder chain
--log-drain — drain (do not show) log lines matching the specified regexp
--log-filter — show only log lines matching the specified regexp
--log-route — log to the specified named logger if the regexp applied on the logline matches
--log-req-route — log requests to the specified named logger if the regexp applied on the logline matches

--use-abort — call abort() on segfault/fpe, could be useful for generating a core dump
--alarm — create a new alarm, syntax: <alarm> <plugin:args>
--alarm-cheap — use the main alarm thread rather than creating dedicated threads for curl-based alarms
--alarm-freq — tune the anti-loop alarm system (default 3 seconds)
--alarm-fd — raise the specified alarm when an fd is read for read (by default it reads 1 byte, set 8 for eventfd)
--alarm-segfault — raise the specified alarm when the segmentation fault handler is executed
--segfault-alarm — raise the specified alarm when the segmentation fault handler is executed 💀
--alarm-backlog — raise the specified alarm when the socket backlog queue is full 🫠
--backlog-alarm — raise the specified alarm when the socket backlog queue is full 🫠
--lq-alarm — raise the specified alarm when the socket backlog queue is full 🫠
--alarm-lq — raise the specified alarm when the socket backlog queue is full 🫠
--alarm-listen-queue — raise the specified alarm when the socket backlog queue is full 🫠
--listen-queue-alarm — raise the specified alarm when the socket backlog queue is full 🫠
--log-alarm — raise the specified alarm when a log line matches the specified regexp — syntax: <alarm>[,alarm...] <regexp> 👑
--alarm-log — raise the specified alarm when a log line matches the specified regexp — syntax: <alarm>[,alarm...] <regexp> 👑
--not-log-alarm — skip the specified alarm when a log line matches the specified regexp — syntax: <alarm>[,alarm...] <regexp> 🙈
--not-alarm-log — skip the specified alarm when a log line matches the specified regexp — syntax: <alarm>[,alarm...] <regexp> 🙈
--alarm-list — list enabled alarms ✨
--alarms-list — list enabled alarms ✨
--alarm-msg-size — set the max size of an alarm message (default 8192) 💅

--log-master — delegate logging to master process 👑
--log-master-bufsize — set the buffer size for the master logger. bigger log messages will be truncated 😭
--log-master-stream — create the master logpipe as SOCK_STREAM 🔌
--log-master-req-stream — create the master requests logpipe as SOCK_STREAM 🔌
--log-reopen — reopen log after reload 🔁
--log-truncate — truncate log on startup ✂️
--log-maxsize — set maximum logfile size 📏
--log-backupname — set logfile name after rotation 🌀
--logdate — prefix logs with date or a strftime string 📅
--log-date — prefix logs with date or a strftime string 📅
--log-prefix — prefix logs with a string 🏷️
--log-zero — log responses without body 🫥
--log-slow — log requests slower than the specified number of milliseconds 🐌
--log-4xx — log requests with a 4xx response 🚨
--log-5xx — log requests with a 5xx response 💥
--log-big — log requests bigger than the specified size 🐘
--log-sendfile — log sendfile requests 📦
--log-ioerror — log requests with io errors 💀
--log-micros — report response time in microseconds instead of milliseconds ⏱️
--log-x-forwarded-for — use the ip from X-Forwarded-For header instead of REMOTE_ADDR 🌐

--master-as-root — leave master process running as root 👑
--drop-after-init — run privileges drop after plugin initialization, superseded by drop-after-apps 🔽
--drop-after-apps — run privileges drop after apps loading, superseded by master-as-root 🔽
--force-cwd — force the initial working directory to the specified value 📂
--binsh — override /bin/sh (used by exec hooks, it always fallback to /bin/sh) 🐚
--chdir — chdir to specified directory before apps loading 📁
--chdir2 — chdir to specified directory after apps loading 📁
--lazy — set lazy mode (load apps in workers instead of master) 😴
--lazy-apps — load apps in each worker instead of the master 😴
--cheap — set cheap mode (spawn workers only after the first request) 🪙
--cheaper — set cheaper mode (adaptive process spawning) 📉
--cheaper-initial — set the initial number of processes to spawn in cheaper mode 🐣
--cheaper-algo — choose the algorithm used for adaptive process spawning 🧠
--cheaper-step — number of additional processes to spawn at each overload 🪜
--cheaper-overload — increase workers after specified overload ⬆️
--cheaper-algo-list — list enabled cheapers algorithms 📋
--cheaper-algos-list — list enabled cheapers algorithms 📋
--cheaper-list — list enabled cheapers algorithms 📋
--cheaper-rss-limit-soft — don't spawn new workers if total resident memory usage of all workers is higher than this limit 🛑
--cheaper-rss-limit-hard — if total workers resident memory usage is higher try to stop workers 🛑
--idle — set idle mode (put uWSGI in cheap mode after inactivity) 💤
--die-on-idle — shutdown uWSGI when idle ☠️
--mount — load application under mountpoint 🗂️
--worker-mount — load application under mountpoint in the specified worker or after workers spawn 👷
--threads — run each worker in prethreaded mode with the specified number of threads 🧵
--thread-stacksize — set threads stacksize 📚
--threads-stacksize — set threads stacksize 📚
--thread-stack-size — set threads stacksize 📚
--threads-stack-size — set threads stacksize 📚
--vhost — enable virtualhosting mode (based on SERVER_NAME variable) 🏠
--vhost-host — enable virtualhosting mode (based on HTTP_HOST variable) 🏠

--route — add a route 🛣️
--route-host — add a route based on Host header 🏷️
--route-uri — add a route based on REQUEST_URI 🔗
--route-qs — add a route based on QUERY_STRING ❓
--route-remote-addr — add a route based on REMOTE_ADDR 🌐
--route-user-agent — add a route based on HTTP_USER_AGENT 🕵️
--route-remote-user — add a route based on REMOTE_USER 👤
--route-referer — add a route based on HTTP_REFERER ↩️
--route-label — add a routing label (for use with goto) 🏷️
--route-if — add a route based on condition 🤔
--route-if-not — add a route based on condition (negate version) 🚫
--route-run — always run the specified route action 🏃
--final-route — add a final route 🏁
--final-route-status — add a final route for the specified status 📌
--final-route-host — add a final route based on Host header 🏷️
--final-route-uri — add a final route based on REQUEST_URI 🔗
--final-route-qs — add a final route based on QUERY_STRING ❓
--final-route-remote-addr — add a final route based on REMOTE_ADDR 🌐
--final-route-user-agent — add a final route based on HTTP_USER_AGENT 🕵️
--final-route-remote-user — add a final route based on REMOTE_USER 👤
--final-route-referer — add a final route based on HTTP_REFERER ↩️
--final-route-label — add a final routing label (for use with goto) 🏷️
--final-route-if — add a final route based on condition 🤔
--final-route-if-not — add a final route based on condition (negate version) 🚫
--final-route-run — always run the specified final route action 🏃
--error-route — add an error route 🚨
--error-route-status — add an error route for the specified status 📌
--error-route-host — add an error route based on Host header 🏷️
--error-route-uri — add an error route based on REQUEST_URI 🔗
--error-route-qs — add an error route based on QUERY_STRING ❓
--error-route-remote-addr — add an error route based on REMOTE_ADDR 🌐
--error-route-user-agent — add an error route based on HTTP_USER_AGENT 🕵️
--error-route-remote-user — add an error route based on REMOTE_USER 👤
--error-route-referer — add an error route based on HTTP_REFERER ↩️
--error-route-label — add an error routing label (for use with goto) 🏷️
--error-route-if — add an error route based on condition 🤔
--error-route-if-not — add an error route based on condition (negate version) 🚫
--error-route-run — always run the specified error route action 🏃
--response-route — add a response route 📬
--response-route-status — add a response route for the specified status 📌
--response-route-host — add a response route based on Host header 🏷️
--response-route-uri — add a response route based on REQUEST_URI 🔗
--response-route-qs — add a response route based on QUERY_STRING ❓
--response-route-remote-addr — add a response route based on REMOTE_ADDR 🌐
--response-route-user-agent — add a response route based on HTTP_USER_AGENT 🕵️
--response-route-remote-user — add a response route based on REMOTE_USER 👤
--response-route-referer — add a response route based on HTTP_REFERER ↩️
--response-route-label — add a response routing label (for use with goto) 🏷️
--response-route-if — add a response route based on condition 🤔
--response-route-if-not — add a response route based on condition (negate version) 🚫
--response-route-run — always run the specified response route action 🏃
--router-list — list enabled routers 📋
--routers-list — list enabled routers 📋
--error-page-403 — add an error page (html) for managed 403 response 🚫
--error-page-404 — add an error page (html) for managed 404 response 🔍
--error-page-500 — add an error page (html) for managed 500 response 💥
--websockets-ping-freq — set the frequency (in seconds) of websockets automatic ping packets 🏓
--websocket-ping-freq — set the frequency (in seconds) of websockets automatic ping packets 🏓
--websockets-pong-tolerance — set the tolerance (in seconds) of websockets ping/pong subsystem 🏓
--websocket-pong-tolerance — set the tolerance (in seconds) of websockets ping/pong subsystem 🏓
--websockets-max-size — set the max allowed size of websocket messages (in Kbytes, default 1024) 📦
--websocket-max-size — set the max allowed size of websocket messages (in Kbytes, default 1024) 📦
--chunked-input-limit — set the max size of a chunked input part (default 1MB, in bytes) 📏
--chunked-input-timeout — set default timeout for chunked input ⏳
--clock — set a clock source 🕰️
--clock-list — list enabled clocks 🕰️
--clocks-list — list enabled clocks 🕰️
--add-header — automatically add HTTP headers to response ➕
--rem-header — automatically remove specified HTTP header from the response ➖
--del-header — automatically remove specified HTTP header from the response ➖
--collect-header — store the specified response header in a request var (syntax: header var) 🗃️
--response-header-collect — stash that response header in a request var, bestie (syntax: header var). 💅
--pull-header — same as above but it also removes the header from the response — sneaky but useful (syntax: header var). ✨
--check-static — check for static files in the directory you specify. 🎀
--check-static-docroot — check for static files in the requested DOCUMENT_ROOT. 🦋
--static-check — check for static files in the specified directory (yes, it's basically the same vibe as --check-static). 🌸
--static-map — map a mountpoint to a static directory (or file). iconic. 💖
--static-map2 — like --static-map but it completely appends the requested resource to the docroot, no cap. 🔥
--static-skip-ext — skip the specified extension when doing static file checks. 🙈
--static-index — if someone requests a directory, search for the file you specify. 👑
--static-safe — skip security checks if the file lives under the path you give. 💀
--static-cache-paths — put resolved paths in the uWSGI cache for the number of seconds you specify. ⭐
--static-cache-paths-name — use the cache you name for static paths. 🌈
--mimefile — set the mime types file path (default is /etc/mime.types). 🍓
--mime-file — same thing, just the other spelling: set the mime types file path (default /etc/mime.types). 🧚
--static-expires-type — set the Expires header based on content type. 💜
--static-expires-type-mtime — set the Expires header based on content type and file mtime. ✨
--static-expires — set the Expires header based on a filename regexp. 🎀
--static-expires-mtime — set the Expires header based on filename regexp and file mtime. 🦋
--static-expires-uri — set the Expires header based on a REQUEST_URI regexp. 🌸
--static-expires-uri-mtime — set the Expires header based on REQUEST_URI regexp and file mtime. 💖
--static-expires-path-info — set the Expires header based on a PATH_INFO regexp. 🔥
--static-expires-path-info-mtime — set the Expires header based on PATH_INFO regexp and file mtime. 👑
--static-gzip — if the regexp you supply matches the static file translation, it'll look for a gzip version. 💀
--static-gzip-all — check for a gzip version of all requested static files. ⭐
--static-gzip-dir — check for a gzip version of all requested static files in the specified dir/prefix. 🌈
--static-gzip-prefix — same as above: check for a gzip version of all requested static files in the specified dir/prefix. 🍓
--static-gzip-ext — check for a gzip version of all requested static files with the specified ext/suffix. 🧚
--static-gzip-suffix — check for a gzip version of all requested static files with the specified ext/suffix. 💜
--honour-range — enable support for the HTTP Range header. ✨
--offload-threads — set the number of offload threads to spawn (per-worker, default 0). 🎀
--offload-thread — same vibe: set the number of offload threads to spawn (per-worker, default 0). 🦋
--file-serve-mode — set static file serving mode. 🌸
--fileserve-mode — set static file serving mode (just the other spelling). 💖
--disable-sendfile — disable sendfile() and rely on boring read()/write(). 🔥
--check-cache — check for response data in the specified cache (empty for the default cache). 👑
--close-on-exec — set close-on-exec on connection sockets (could be required for spawning processes in requests). 💀
--close-on-exec2 — set close-on-exec on server sockets (could be required for spawning processes in requests). ⭐
--mode — set uWSGI custom mode. 🌈
--env — set environment variable. 🍓
--envdir — load a daemontools compatible envdir. 🧚
--early-envdir — load a daemontools compatible envdir ASAP. 💜
--unenv — unset environment variable. ✨
--vacuum — try to remove all of the generated file/sockets. 🎀
--file-write — write the specified content to the specified file (syntax: file=value) before privileges drop. 🦋
--cgroup — put the processes in the specified cgroup. 🌸
--cgroup-opt — set a value in the specified cgroup option. 💖
--cgroup-dir-mode — set permission for cgroup directory (default is 700). 🔥
--namespace — run in a new namespace under the specified rootfs. 👑
--namespace-keep-mount — keep the specified mountpoint in your namespace. 💀
--ns — run in a new namespace under the specified rootfs (yep, same as --namespace). ⭐
--namespace-net — add network namespace. 🌈
--ns-net — add network namespace (same thing, shorter name). 🍓
--enable-proxy-protocol — enable PROXY1 protocol support (only for http parsers). 🧚
--reuse-port — enable REUSE_PORT flag on socket (BSD only). 💜
--tcp-fast-open — enable TCP_FASTOPEN flag on TCP sockets with the specified qlen value. ✨
--tcp-fastopen — same: enable TCP_FASTOPEN flag on TCP sockets with the specified qlen value. 🎀
--tcp-fast-open-client — use sendto(..., MSG_FASTOPEN, ...) instead of connect() if supported. 🦋
--tcp-fastopen-client — same: use sendto(..., MSG_FASTOPEN, ...) instead of connect() if supported. 🌸
--zerg — attach to a zerg server. 💖
--zerg-fallback — fallback to normal sockets if the zerg server is not available. 🔥
--zerg-server — enable the zerg server on the specified UNIX socket. 👑
--cron — add a cron task. 💀
--cron2 — add a cron task (key=val syntax). ⭐
--unique-cron — add a unique cron task. 🌈
--cron-harakiri — set the maximum time (in seconds) we wait for a cron command to complete. 🍓
--legion-cron — add a cron task runnable only when the instance is a lord of the specified legion. 🧚
--cron-legion — add a cron task runnable only when the instance is a lord of the specified legion (same as above). 💜
--unique-legion-cron — add a unique cron task runnable only when the instance is a lord of the specified legion. ✨
--unique-cron-legion — add a unique cron task runnable only when the instance is a lord of the specified legion. 🎀
--loop — select the uWSGI loop engine. 🦋
--loop-list — list enabled loop engines. 🌸
--loops-list — list enabled loop engines (yes, same thing). 💖
--worker-exec — run the specified command as worker. 🔥
--worker-exec2 — run the specified command as worker (after post_fork hook). 👑
--attach-daemon — attach a command/daemon to the master process (the command has to not go in background). 💀
--attach-control-daemon — attach a command/daemon to the master process (the command has to not go in background), and when the daemon dies, the master dies too. ⭐
--smart-attach-daemon — attach a command/daemon to the master process managed by a pidfile (the command has to daemonize). 🌈
--smart-attach-daemon2 — attach a command/daemon to the master process managed by a pidfile (the command has to NOT daemonize). 🍓
--legion-attach-daemon — same as --attach-daemon but the daemon runs only on a legion lord node. 🧚
--legion-smart-attach-daemon — same as --smart-attach-daemon but the daemon runs only on a legion lord node. 💜
--legion-smart-attach-daemon2 — same as --smart-attach-daemon2 but the daemon runs only on a legion lord node. ✨
--daemons-honour-stdin — do not change the stdin of external daemons to /dev/null. 🎀
--attach-daemon2 — attach-daemon keyval variant (supports smart modes too). 🦋
--plugins — load uWSGI plugins. 🌸
--plugin — load uWSGI plugins (same thing). 💖
--need-plugins — load uWSGI plugins (exit on error). 🔥
--need-plugin — load uWSGI plugins (exit on error, same as above). 👑
--plugins-dir — add a directory to the uWSGI plugin search path. 💀
--plugin-dir — add a directory to the uWSGI plugin search path (same vibe). ⭐
--plugins-list — list enabled plugins. 🌈
--plugin-list — list enabled plugins (yes, again). 🍓
--autoload — try to automatically load plugins when unknown options are found. 🧚
--dlopen — blindly load a shared library. 💜
--allowed-modifiers — comma separated list of allowed modifiers. ✨
--remap-modifier — remap request modifier from one id to another. 🎀
--dump-options — dump the full list of available options. 🦋
--show-config — show the current config reformatted as ini. 🌸
--binary-append-data — return the content of a resource to stdout for appending to a uwsgi binary (for data:// usage). 💖
--print — simple print. 🔥
--iprint — simple print (immediate version). 👑
--exit — force exit() of the instance. 💀
--cflags — report uWSGI CFLAGS (useful for building external plugins). ⭐
--dot-h — dump the uwsgi.h used for building the core (useful for building external plugins). 🌈
--config-py — dump the uwsgiconfig.py used for building the core (useful for building external plugins). 🍓
--build-plugin — build a uWSGI plugin for the current binary. 🧚
--version — print uWSGI version. 💜
--response-headers-limit — set response header maximum size (default: 64k). ✨

And that's the whole options list, bestie! You made it. 💅 This page is from uwsgi_jvm_openjdk11 version 2.0.20-debian, dated March 2022 — so go forth and configure with main character energy. 🫶👑💖

📦 where this page comes from

ubuntu jammy: uwsgi-plugin-jvm-openjdk-11 2.0.20-4 · GPL-2.0-only
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-18: a language model's rewrite of the original, under its terms