ACTIVE BOUNTIES

You are the architect of the Ronin Engine (`ronin-core`). Your goal is to build a container orchestration runtime that makes Kubernetes look like a bloatware toy. We need sub-millisecond cold starts, zero-copy networking, and memory safety that would make the NSA jealous.

• Architecting the low-level process isolation logic using Linux Namespaces and cgroups v2.
• Replacing standard libc calls with optimized Assembly where necessary to shave off microseconds.
• Debugging memory leaks using Valgrind, Flamegraphs, and pure intuition.
• Reviewing every line of Rust code that enters the repo. You are the gatekeeper.

Must have 8+ years in Systems Programming. Must have shipped a production Rust binary. Must hate garbage collection.

Build our custom Reverse Proxy edge layer. NGINX is great, but we need something faster and more programmable. You will build the traffic controller that routes millions of requests per second to millions of containers.

• Writing high-performance, asynchronous C++ networking code (ASIO/epoll).
• Implementing custom load balancing algorithms (Least Connections, Round Robin, etc.).
• Handling automatic SSL termination via Let's Encrypt integration at the C++ level.

Cut your teeth on the hardest codebase in the world. You will start by building the Ronin CLI tool (which developers use to deploy) and writing integration tests for the core engine.

• Maintaining the `ronin-cli` crate (Clap, Tokio).
• Writing unit tests that cover edge cases in the deployment logic.
• Fixing "Good First Issue" bugs in the core engine under supervision.

React is banned. You are the master of Vue 3. You will build the Ronin Dashboard, a mission-critical control center that streams real-time logs, metrics, and deployment statuses via WebSockets. It must be 60fps at all times.

• Designing the component architecture using Vue 3 Composition API and Pinia.
• Implementing virtual scrolling for log outputs that might contain millions of lines.
• Ensuring zero layout shift (CLS) during real-time updates.

Manage our SSR infrastructure. You will use Nuxt 3 and Nitro to deliver instant page loads. You are also responsible for the BFF (Backend for Frontend) layer that talks to the Rust core.

• Optimizing Nitro server routes for edge deployment.
• Managing hydration strategies to keep Time-To-Interactive low.
• Building middleware for authentication and role-based access control.

Make it look like a sci-fi movie. We want micro-interactions, particle effects when a build finishes, and glitch effects on hover. Use GSAP and Three.js within the Vue ecosystem.

Keep the lights on. You manage the underlying physical and cloud infrastructure that powers Ronin Cloud. You are responsible for high availability, disaster recovery, and automated scaling.

• Managing bare-metal clusters via Terraform / Ansible.
• Setting up Prometheus/Grafana dashboards to monitor core temperature of servers in Frankfurt.
• Responding to incidents at 3 AM (we pay extra for this).

Scale our Postgres clusters. Ronin users generate millions of logs and build events. We need you to tune autovacuum, optimize indexes, and handle sharding strategies.

Your job is to break Ronin. We want you to find container escape vulnerabilities, network isolation breaches, and XSS flaws before the bad guys do.

You are the face of the rebellion. Create content that developers actually want to watch. Speak at conferences. Start flame wars (respectfully) about why Serverless is a scam.

Good software with bad docs is bad software. Your job is to make the Ronin documentation better than Stripe's. Write tutorials, API references, and migration guides.

Users will write bad Dockerfiles. They will blame us. You will calmly show them their syntax error. You need to be technical enough to debug Linux environments but patient enough to handle humans.

We are moving from standard TLS to Zero-Knowledge Proofs for user authentication. You will implement ZK-SNARKs in Rust. If you get the math wrong, our customers' data is public domain. Don't get it wrong.

• Implementing Elliptic Curve arithmetic in pure Rust (no C bindings).
• Auditing our key exchange protocols against quantum threats.
• Optimizing finite field operations for performance.

DOM elements are boring. You will build a custom WebGL renderer for our real-time global infrastructure map. We want raw GLSL shaders. Make it look like the War Room in Dr. Strangelove, but in 4K.

• Writing fragment and vertex shaders from scratch.
• Optimizing geometry instancing to render 50k+ nodes at 60fps.
• Bypassing Vue reactivity for direct canvas manipulation.

Your job is to break production on purpose. You will write bots that randomly kill pods, sever network connections, and corrupt databases to ensure our auto-recovery scripts actually work. You are the villain.

• Designing failure injection experiments (Gremlin / Chaos Mesh).
• Analyzing "Blast Radius" of potential outages.
• Making the SRE team hate you, then respect you.

You are the bridge between our code and their money. You don't just sell; you build Proof of Concepts (POCs) live on the call to prove our tech is superior. You need to out-code the client's CTO.

• Building custom demos that integrate Ronin into legacy enterprise stacks.
• Translating "Manager Speak" into technical requirements.
• Flying to on-site deployments to "fix it live."

We aren't training models; we are running them. Fast. You will optimize the Ronin Inference Engine to run LLMs on consumer hardware with minimal latency. You will deal with quantization, memory paging, and CUDA kernels.

• Writing custom CUDA/ROCm kernels for matrix multiplication.
• Implementing quantization techniques (GGUF/GPTQ) in pure Rust/C++.
• Optimizing memory bandwidth usage on APUs.

We are deploying custom hardware appliances to datacenters. There is no OS. There is only a `main()` loop and raw memory registers. You will write the bootloader and the driver stack.

• Writing ARM Cortex-M assembly for interrupt handlers.
• Bit-banging protocols over GPIO because hardware offload failed.
• Debugging over JTAG while the board is literally on fire.