C++ Projects on Upwork: Find Your Next Job

Deseo encapsular dos estrategias existentes de NinjaTrader 8 dentro de una interfaz de escritorio pulida, de modo que pueda gestionarlas sin necesidad de tocar el editor de código. El trabajo se centra principalmente en la interfaz gráfica (GUI), pero debe mantenerse estrechamente vinculado a la lógica de NinjaScript que ya ha sido finalizada.

Funcionalidades principales a implementar:
• Una ventana única (utilizando WPF o WinForms dentro de NinjaTrader) que me permita seleccionar cualquiera de las dos estrategias, iniciarlas/detenerlas y ajustar sobre la marcha cada uno de los parámetros expuestos. Se aceptan controles deslizantes, menús desplegables y cuadros de texto, siempre y cuando el diseño sea limpio y adaptable (responsive).
• Comportamiento completo de "bot": las estrategias deben continuar colocando órdenes de compra y venta de forma automática una vez que se hayan activado desde el panel.
• Acceso con un solo clic al motor de optimización de NinjaTrader, para poder iniciar un ciclo de optimización y supervisar su progreso/resultados sin salir de la interfaz.
• Una pequeña sección donde pueda introducir o pegar valores numéricos personalizados (entrada manual de datos) que las estrategias leerán de forma inmediata.

Criterios de aceptación:
1. Las estrategias se compilan y ejecutan en NinjaTrader 8 sin sufrir ninguna modificación en su lógica de trading actual.
2. Todos los parámetros visibles en el código quedan expuestos en la interfaz y se conservan entre sesiones.
3. El envío de órdenes, el seguimiento de posiciones y la optimización pueden activarse exclusivamente desde la nueva ventana.

Si se siente cómodo trabajando con C#, NinjaScript y WPF/WinForms, y cuenta con experiencia en la automatización de la ejecución de operaciones de trading, me gustaría saber cómo estructuraría el proyecto y cuál sería su cronograma estimado para la entrega final de la versión con ambas estrategias integradas.

Skills: .NET, Data Entry, C# Programming, C++ Programming, WPF, Software Development, Visual Studio, Software Engineering, Desktop Application, NinjaTrader

Hiring a second long-term retainer for our trading team.

Looking for someone who lives at the intersection of algorithmic trading and software engineering and treats them as the same problem, not separate ones. You'll be working in a real quant environment: hypothesis-driven testing, structured logging, edge measurement, walk-forward discipline. Most of the day-to-day is real SWE work alongside it patching builds, bumping app versions, maintaining running systems, writing pipelines that don't fall over at 3am. We need someone who sees "ship clean code" and "ship a working strategy" as one job.


WHAT WE ACTUALLY DO

We run two products that share a team. The first is a multi-strategy algorithmic trading platform Python, FastAPI, Docker, Redis, PostgreSQL, deployed on VPS. Strategy library, backtesting harness, execution layer, data ingestion, signal scoring and routing. This is the harder of the two and the centre of gravity for this role.

The second is a multi-tenant platform in a different domain. Smaller engineering surface, more standard CRUD + auth + dashboards, but real production work the same person should be comfortable jumping into. If you can carry your weight on the trading platform, the second product is straightforward.


WHAT YOU'D OWN

- Components of the trading platform: strategy library, backtesting harness, execution layer, data ingestion
- Data integrity through the system leakage, point-in-time correctness, gap handling
- Real SWE alongside it: VPS maintenance, FastAPI services, Docker deployments, version bumps, debugging in production
- Tickets on the second product when the trading platform isn't burning


WHAT YOU SHOULD BE ABLE TO TALK ABOUT

- Out-of-sample testing vs walk-forward optimization, and when each is right
- What "edge" actually means and how you'd measure it
- Why pipeline paranoia matters more than model sophistication
- How market data flows from ingestion through to execution, and where it's most likely to break

If those topics light you up rather than make you reach for ChatGPT, we should talk.


MUST-HAVES

- Strong Python with real Git, testing, and modular architecture habits
- At least one backtesting framework you've actually used (yours, MetaTrader, QuantConnect, Backtrader, vectorbt matter which)
- FastAPI, Redis, Docker, PostgreSQL, VPS deployment
- Market microstructure intuition (spreads, slippage, order book depth)
- Honest about gaps. "I haven't done that, but I'd approach it like X" beats a confident wrong answer
- Clear written English


NICE TO HAVE

- Rust or C++
- Live strategy track record yours, hobby, paper, anything real
- Quant / CS / physics / math background
- MQL5 / MetaTrader


FIT

We work best with people who give this their full attention. If you're actively building or selling your own algo trading product, this isn't the right role we'd rather you focus on that. If trading and engineering are something you're genuinely curious about and want to deepen through real work, we are.

Filtering out: backtest-only resumes, indicator-stackers, mid-project ghosters.


STRUCTURE

- Long-term retainer, $1,000–1,500/month depending on hours and seniority
- Async-friendly, remote, 20–30 hrs/week
- NDA + IP-assignment on signing plain English, not corporate


WHEN YOU APPLY, ANSWER BRIEFLY:

1. Difference between out-of-sample testing and walk-forward optimization, and why does it matter?
2. A strategy you've worked on (paper, hobby, or production), and what you learned from it that you didn't expect.
3. Are you currently running your own algorithmic trading product that this role would compete with?

Short answers are fine. We read for honesty and how you think, not polish.

AI-GENERATED APPLICATIONS WILL NOT BE INVITED TO INTERVIEW. We can spot them in 30 seconds the structure, the cadence, the safe corporate verbs. Three sentences of real thought from you beats three paragraphs of ChatGPT prose. If your cover letter could have been written about any job, it tells us nothing about you, and we'll move on.

Rust and C/C++. Build a C++/Vulkan or Rust/WGPU, 'Ghost Gates'. Target 120FPS on an integrated mobile GPU. Model-View-Projection (MVP) matrices and Quaternions is a big plus. Vulkan Expertise. Performance Optimization (SIMD/Cache)

Overview
We are looking for an experienced engineer to complete a partially implemented Simulcrypt (conditional access) integration in an existing C++ video processing system.
The system architecture is already in place, including:
• stvmux (mux/controller)
• stvenc (encoder/service)
• Mosquitto (MQTT) for IPC
• Partial Simulcrypt framework
Your role is to complete the Simulcrypt implementation, integrate with an ECMG, and finalize end-to-end ECM flow.

What You Will Do
You will:
• Implement Simulcrypt workflow between mux and encoder components
• Build ECMG socket interface (TCP-based protocol)
• Complete MQTT-based IPC between services
• Implement PMT updates with additional CA descriptors
• Handle ECM request/response flow
• Ensure MPEG-TS compliance and stream integrity
• Implement lifecycle handling (stream setup/teardown)
• Add failure handling (ECMG disconnect, recovery)
You will first integrate with a standalone ECMG (test system), then optionally adapt to a vendor-specific interface.

Required Skills (Must Have)
Core Engineering
• Strong C++ (Linux, multithreaded systems)
• Experience with socket programming (TCP client/server)
• Experience with event-driven systems or IPC
Video / Broadcast (Critical)
• Deep understanding of MPEG-TS (Transport Stream)
• Experience with:
o PAT / PMT structure
o PID management
o CA descriptors
• Understanding of DVB / ATSC signaling (at least at PSI/SI level)
Conditional Access / Simulcrypt
• Experience with at least one of:
o Simulcrypt
o ECMG / EMMG interfaces
o CAS systems (Widevine, Verimatrix, Irdeto, Nagra, etc.)
• Understanding of:
o ECM lifecycle
o crypto periods
o CA system IDs
Messaging / IPC
• Experience with MQTT (Mosquitto preferred)
• Designing topic structures and message flows

Strongly Preferred (Will Move You to Top)
• Prior work with Simulcrypt (huge plus)
• Experience integrating with ECMG systems
• Experience modifying live transport streams in real time
• Familiarity with tools like:
o TSDuck
o ffmpeg (TS-level understanding, not just transcoding)
• Experience with low-latency or real-time video systems

What Already Exists (Important)
• Working stvenc implementation real time encryption
• Partial stvmux implementation (Simulcrypt hooks exist but incomplete)
• Documented flow of expected Simulcrypt behavior
• Standalone ECMG available for testing
This is not a greenfield project — you are completing and wiring existing components.

Deliverables
1. Completed stvmux::setup_mosq_io() with working MQTT messaging
2. Fully functional Simulcrypt class with ECMG connection
3. End-to-end flow:
o Stream setup → PMT update → ECM request → ECM insertion
4. Proper CA descriptor insertion into PMT
5. Stable ECM request/response handling
6. Stream add/remove lifecycle support
7. ECMG failure handling and recovery logic
8. Basic logging and debug visibility

• 1. Describe your experience working with MPEG Transport Streams. (Have you modified PMTs or inserted descriptors?)
• 2. Have you worked with conditional access systems or Simulcrypt? If yes, describe the system and your role.
• 3. Have you ever integrated with an ECMG or similar encryption/key system?
• 5. What tools have you used for TS analysis or debugging?

I am looking for an experienced C++ developer to assist with a research project on a legacy client-server application. I've already identified several variables in the "player-status" block that are being overwritten by the server, and I need a memory-level solution to manage these values locally.
The scope involves developing a method to lock these specific variable offsets in RAM via DLL injection to test client stability during sync interruptions. Additionally, you will need to implement a local hook to redirect specific internal ID requests to alternative data tables and intercept an outgoing transaction packet to simulate modified data for validation testing.
I need a clean EXE loader with a simple toggle interface for these features. You should have a strong background in reverse engineering, memory offsets, and packet analysis. I will provide the list of target variables and a test environment for debugging. No amateurs please—I need someone who understands memory-level persistence and redirection.

Skills: C Programming, C# Programming, Software Architecture, C++ Programming, Software Development, Reverse Engineering, Visual Studio, API Development, API Integration, Software Engineering

We are seeking an experienced full stack developer to help build and enhance our Virtual Events and Office platform. The ideal candidate will have a strong background in both front-end and back-end development, and be proficient in creating engaging, user-friendly interfaces as well as robust server-side applications. You will collaborate with our design and product teams to implement features and improve functionality. If you're passionate about creating seamless online experiences, we want to hear from you!

ffmpeg restream stream with mapped subttitle

i have stream with embedded subtitles inside i need a way force play selected subttilte as default and restream it with default sub enabled. no encoding.

Skills: C Programming, Python, Linux, Software Architecture, C++ Programming, Video Streaming

We are seeking an experienced Rust trainer with a strong systems programming background to deliver an advanced, accelerated Rust workshop for a team of experienced C/C++ engineers.

Program Overview
(link removed)

NP SOP
(link removed)

This training will be conducted onsite in Irvine, California, with a hybrid format where a few participants will join remotely.

The team already has deep experience with modern C++ and C, including RAII, memory management, and systems-level architecture. The goal of this workshop is not introductory Rust, but rather a translation of C++ patterns and mental models into idiomatic Rust.

The course should emphasize practical, hands-on learning and real-world engineering patterns.

⸻

Engagement Overview

Location
Irvine, California (onsite)

Delivery Format
Hybrid
6–7 participants onsite
2–3 participants remote

Duration Options
2 or 3 consecutive days

Daily Schedule
9:00 AM – 4:00 PM
6 hours instruction + 1 hour breaks

Participants
9 software engineers

Target Timing
Q2 2026

⸻

Audience Background

Participants are experienced systems engineers with strong knowledge of:

• Modern C++
• C
• RAII
• Smart pointers
• Multithreading
• Low-level architecture

The training should skip introductory programming concepts and instead focus on advanced Rust concepts mapped to familiar C++ patterns.

⸻

Key Topics of Interest

Ownership vs Smart Pointers
Deep dive into the borrow checker and comparisons to std::unique_ptr and std::shared_ptr

Zero-Cost Abstractions
Traits vs templates / SFINAE
Static vs dynamic dispatch
Trait objects and virtual tables

FFI and Interoperability
Best practices for wrapping existing C/C++ libraries
Incremental migration strategies

Concurrency
Send and Sync traits
Rust concurrency model vs C++ threading pitfalls

Unsafe Rust
When and how to use it responsibly
Creating safe abstractions over unsafe code

Promises and Futures
Async Rust fundamentals
Futures and async execution models

⸻

Hybrid Delivery Requirement (Important)

The trainer must be comfortable delivering in a hybrid environment, ensuring remote participants can fully engage with:

• whiteboard discussions
• coding demonstrations
• hands-on labs
• Q&A interaction

⸻

What We’re Looking For

Ideal trainers will have:

• Strong professional experience with Rust in production environments
• A systems programming background (Rust, C++, or C)
• Experience teaching advanced technical audiences
• Comfort explaining Rust concepts to engineers coming from C/C++

Training should be hands-on and practical, with labs and exercises throughout the workshop.

⸻

To Apply

Please include:
1. A brief overview of your Rust experience and systems programming background
2. Any Rust training or workshops you have delivered previously
3. An example outline or syllabus for an advanced Rust course (if available)

I need a fully automated NinjaTrader (NinjaScript 8) strategy that:

• Monitors two exponential moving averages of my choice and fires a trade the moment the fast EMA crosses above or below the slow EMA. A bullish cross should open an initial long market order; a bearish cross should open an initial short.

• At the same time the strategy must submit two additional limit orders so I can scale in. The price levels for those limits will be input parameters; once filled, all three positions must merge into a single virtual position managed by one stop-loss and one profit target.

• Both the stop and the target use fixed point values, also supplied as user inputs. If price reaches the profit target before the extra limits are filled, the strategy must automatically cancel the resting limits, flatten the filled position, and reset itself for the next cross.

• Normal NinjaTrader strategy requirements apply—proper OnStateChange handling, parameter panel, tick-by-tick position tracking, and zero historical/real-time discrepancies.

Deliverables
1. Compilable .cs file with clean, well-commented NinjaScript 8 code.
2. Short PDF or README explaining every input (fast EMA period, slow EMA period, limit offsets, stop, target, etc.) and the reset logic.
3. Brief live-data demonstration or video so I can see the scaling and cancel-if-profit-hit behaviour working.

The code must compile without third-party add-ons, follow NinjaTrader best practices, and be ready for forward test on live data.

Skills: C Programming, C# Programming, Software Architecture, Metatrader, Financial Markets, C++ Programming, Risk Management, Market Analysis, Backtesting, NinjaTrader

We are seeking an AI engineer to develop a bot that integrates with WhatsApp and our stock software. The bot should be able to receive and process messages, update stock levels, and send notifications. The ideal candidate will have experience in AI, bot development, and API integration. This is a part-time role with a project duration of 1 to 3 months.

Buscamos un programador experimentado en SIEMENS que pueda establecer la comunicación entre un controlador Logo V8 y LabView, además de implementar un control PID. El proyecto tiene una duración breve y debe completarse en un día. Si tienes experiencia en la programación de sistemas de automatización y un sólido entendimiento de LabView, estaremos encantados de recibir tu propuesta.

I have a complete user-interface already laid out as a series of high-resolution PNGs. Your task is to reproduce every pixel of those screens in WPF using pure XAML—absolutely no WinForms and no creative interpretation. The PNG set covers both dark and light themes and includes the folder, grid, and list style views exactly as they must appear in the final build.

What I need from you is a clean Visual Studio solution that opens, compiles, and runs with both themes switchable at runtime. The finished XAML should match the supplied images at 1:1 scale on standard DPI settings, handle basic resizing without layout distortion, and keep all colours, fonts, margins, and icon placements identical.

Deliverables
• WPF project/solution with all XAML files organised logically
• Resource dictionaries (or equivalent) for dark and light modes
• Any image, vector, or font assets wired up and referenced correctly
• A short read-me that explains how to toggle themes and where key resources live

Acceptance criteria
The compiled executable must visually match the provided PNGs side-by-side, with no stray pixels or spacing differences, and run without third-party dependency issues.

If recreating UIs at the pixel level is second nature to you, I’m ready to share the design pack and get started right away.

Go to the website to view the 9-1-1 Reality Simulator as this is the product that will require this new skin. Currently we are using wallpapers with folders and this is dated and unprofessional for this product. The UI must include:

-Main Dashboard / Start Simulation screen
-Folder View (grid/list with left menu, center list, right details panel)
-Dark and Light versions of all screens
-Sidebar navigation with active states
-Selected folder detail paneL

The application must NOT look like a standard Windows application in any way.
No default controls, borders, fonts, or system styling. You must understand the product 9-1-1 Reality Simulators at www.911CareerTraining.com and see there are 3 models, inactive monitors needing skin.

REQUIRED CREDENTIALS - Requiring proof as I have had two not good experiences trying to hire the right person on Freelancer and Upwork: First person language barrier so I need English as a first language. Second person no design ability could not reproduce exactly what was already designed. No canned responses please.

Expert-level WPF (Windows Presentation Foundation)

Must work directly in XAML (not WinForms, not web wrappers). Pixel-perfect UI implementation experience. UI/UX implementation (NOT design - WE PROVIDE).Graphics handling inside WPF.

Skills: .NET, C# Programming, C++ Programming, WPF, XAML, Visual Studio, Desktop Application

ffmpeg closed captions show in players automatic play exoplayer and other players like xciptv/iboplayer/netiptv

- ! no encoding i know to burnin mode!

if you are not familar with this kind of players dont waste my time.
We already have multiple subtitles in stream, it doesnt get auto selected.
i dont want use web vtt or something else. because it is already inside the stream it self
mpeg-ts

Skills: C Programming, C++ Programming, Video Processing, Video Streaming

We need a senior C++ graphics/game engine programmer to modernize a legacy DirectX 9Ex MMORPG renderer.

The project currently uses:
- DirectX 9Ex
- fixed-function pipeline
- FVF
- SetRenderState / SetTextureStageState
- D3DXMATRIX
- custom StateManager
- Granny model rendering
- terrain/splat rendering
- UI quad rendering
- particle/effect rendering

Goal:
- Build a renderer abstraction layer
- Keep the existing DX9Ex backend working
- Add a modern backend step by step, preferably DX11 first, optional DX12 later
- First milestone: technical audit + minimal clear/UI render

I have a specific song on Spotify that I’d like to keep offline. I already have the direct Spotify URL and will pass it along once we start chatting—just not posting it here publicly.

Your task is to grab that exact recording (or an identical master from another licensed source, if that speeds things up) and deliver it as a high-fidelity 320 kbps MP3. Please make sure the audio comes from a lossless or very high-quality source so no detail is lost; a simple transcode from a lower bitrate won’t work.

Deliverable:
• One MP3 file in 320 kbps, tagged with correct artist, title, and album art if possible.

A quick turnaround is appreciated. Let me know if you need anything else from my side.

Skills: Audio Services, Music, C++ Programming, Audio Production, Audio Editing, Audio Mastering, Audio Engineering, Music Production

I'm seeking an experienced trader and coder to develop a trend-following algorithmic trading strategy for the NSE, specifically for futures and options. The strategy should be based on price action indicators.

Key Requirements:
- Expertise in algorithmic trading and coding
- Experience with trend-following strategies
- In-depth knowledge of NSE, futures, and options
- Strong understanding of price action techniques

Ideal Skills:
- Proficiency in programming languages such as Python, R, or C++
- Background in financial markets and trading strategies
- Ability to backtest and optimize trading algorithms
- Good communication skills for regular updates

Please provide examples of previous work and relevant experience.

Skills: C Programming, Python

I need a modified version of the DPMFoam solver in OpenFOAM to simulate heated particle-laden flow. The modifications should include:

- Energy equation addition for both fluid and particle phases
- Implement heat transfer model
- Conduction
- Convection
- Radiation
- Boundary conditions for heat transfer to be set as convective heat flux

Ideal skills and experience:
- Proficient in C/C++
- Experience with OpenFOAM and DPMFoam
- Knowledge of heat transfer principles and fluid dynamics

Skills: Engineering, Matlab and Mathematica, C# Programming, Mechanical Engineering, C++ Programming, Thermal Analysis, Simulation, Computational Fluid Dynamics

Need several developers for complex project to join to my team. You can attach your CV.

Software engineers to design and build high-performance backend systems and services
Data engineers to develop and maintain real-time and batch data processing pipelines
DevOps engineers to manage infrastructure, deployments, and system reliability (primarily on Linux environments)
Network engineers to optimize low-latency, high-throughput communication systems

We are building a performance-critical real-time system that processes high-throughput data streams and requires deterministic, ultra-low-latency execution.

We are looking for engineers with strong experience in systems programming and performance optimization to help design and implement core components.

Responsibilities include:

Developing and optimizing latency-sensitive backend services in C/C++
Working with real-time data ingestion and processing pipelines
Profiling and improving system performance (CPU, memory, networking)
Ensuring reliability and consistency under high load

Nice to have:

Experience with kernel-level optimizations or networking stacks
Familiarity with high-throughput messaging systems
Background in performance-critical environments (e.g. telecom, gaming, embedded systems)

We value clean, efficient code and a strong understanding of how software interacts with hardware.

Skills: C Programming, Python, Linux, Data Processing, C++ Programming, Network Administration, Backend Development, DevOps, Network Engineering, Software Engineering

I’m looking for a straightforward, file-based contact manager written in modern C++. The data has to live in a local file so that every addition, deletion, or edit is waiting the next time the program is launched—no external database at all.

The program should follow clean object-oriented design and lean on the STL for containers and algorithms. From the command-line menu a user must be able to add new contacts, remove existing ones, search by name, phone number, or email, sort the entire list on any of those fields, and export the whole book to a separate file (CSV or similar).

Readable prompts, robust error handling, and cross-platform compilation with any C++17-compatible compiler are essential.

Deliverables
• Complete, well-commented C++ source and header files
• A sample contacts file for quick testing
• A brief README with compile and run instructions

Acceptance criteria
• Compiles cleanly under C++17 with g++ or clang
• Add/remove, search, sort, and export all function exactly as described
• Contact data persists solely through the file system using the standard library

Skills: C Programming, Java, C# Programming, C++ Programming, Debugging, Software Development, Object Oriented Programming (OOP), Software Engineering

I’m building a fully-automated pipeline that turns any ​.wav file into a finished, high-quality MP4 music video without the per-video fees of online generators like Neuralframes. My workflow needs to live in a clean Anaconda environment and rely on the latest releases of Flux together with Hunyuan-Video in GGUF format as the core engines.

Here’s the flow I want the script to cover:

• Ingest a user-supplied ​.wav
• Detect its BPM automatically and segment it into logical beats
• Transcribe the vocals, generate editable lyrics, and let me tweak or overwrite them before render time
• For roughly 65 beat-aligned segments, build a text prompt list (also editable) that feeds Flux + Hunyuan-Video to create matching frames
• Stitch the generated frames and original audio into a single MP4, perfectly synced
• Run headless so I can batch 1,000+ tracks with simple CLI commands; no GUI polish required, just stability, logging, and clear config files

Key expectations
• Python 3.11+ in Anaconda, modularized for easy updates of models
• Output video must be 1080p or higher, H.264 in MP4 container
• External dependencies such as ffmpeg, whisper, librosa (or your preferred audio library) and any model weights should auto-download or be documented in the environment.yml
• A short README and sample run script that processes one demo song end-to-end

Acceptance
I’ll run the suite on a fresh machine, point it at a test .wav, adjust a couple of generated prompts, and get a synchronized MP4 with no manual video editing. If that passes and the code is clearly organized for scaling, the job is complete.

**Project Title:**
AI Music Video Generator (Desktop Software – Python)

---

## Overview

Develop a **desktop application** that generates full-length AI music videos from a WAV audio file and lyrics input. The software must provide **fine-grained manual control over every scene**, while also supporting AI-assisted automation.

The goal is to replicate and exceed tools like Neural Frames by allowing:

* Scene-by-scene control
* Frame-by-frame prompting
* AI image and video generation
* Full synchronization with music and lyrics

---

## Core Functional Requirements

### 1. Audio Input & Analysis

* Import `.wav` audio files
* Automatically analyze:

* BPM (tempo)
* Beat structure
* Song sections (intro, verse, chorus, drop)
* Generate a **timeline of scenes** based on audio segmentation

---

### 2. Lyrics Integration & Sync

* Input lyrics manually (paste text)
* Automatically align lyrics with timestamps using speech-to-text alignment
* Display lyrics synced to timeline

---

### 3. Scene Timeline Editor

* Visual timeline of the entire song
* Split into 50–100 scenes (auto + manual override)
* Each scene:

* Clickable
* Plays only that segment of audio
* User can:

* Adjust scene duration
* Merge/split scenes
* Reorder scenes

---

### 4. Scene Prompt System

Each scene must allow:

* Image prompt input (what to generate visually)
* Motion prompt input (how it animates)
* Ability to preview and edit prompts per scene

---

### 5. Image Generation Engine

* Generate **high-quality images per scene**
* Support modern models (e.g. FLUX / Stable Diffusion-class)
* Batch or single-frame generation
* Save images per scene

---

### 6. Video Generation Engine

* Convert generated images into animated video clips
* Support:

* Camera movement (zoom, pan, rotation)
* Motion prompts
* Generate short clips (2–6 seconds per scene)

---

### 7. Clip Management System

* Store all generated clips per scene
* Allow:

* Regenerate clips
* Replace clips
* Preview clips individually

---

### 8. Final Video Assembly

* Automatically stitch all clips together
* Ensure:

* Correct timing
* Smooth transitions
* Overlay original WAV audio
* Export final video (MP4)

---

### 9. Playback System

* Preview:

* Individual scenes
* Full video
* Sync playback with audio

---

## Technical Requirements

### Language & Environment

* Python (Anaconda-compatible)
* Must run locally on Windows

### GUI Framework

* PySide6 (Qt-based modern interface)

### AI Integration

* Must support integration with:

* Image generation models
* Video generation models
* Modular backend (models can be swapped)

### Video Processing

* FFmpeg integration required

---

## File & Project Structure

Each project should store:

* Audio file
* Lyrics
* Scene data (JSON)
* Generated images
* Generated clips
* Final output

---

## Advanced Features (Preferred)

* Beat-synced cuts and transitions
* AI-assisted prompt generation
* Style consistency across scenes
* Character continuity (optional)
* GPU acceleration (CUDA support)

---

## Deliverables

* Fully working desktop application
* Clean, maintainable Python code
* Installation/setup instructions
* Ability to run locally without cloud dependency (preferred)

---

## Notes for Developer

* This is not a simple generator — it is a **production tool**
* User control over scenes is critical
* Performance and stability are important
* Modular design is required for future upgrades

---

## Objective

Create a tool that enables a single user to generate professional-quality AI music videos with full creative control, combining automation with manual direction.

Skills: Python, Software Architecture, Transcription, Machine Learning (ML), C++ Programming, Arduino, Video Production, Video Editing, Audio Processing, Automation

I want to step into Teardown and explore its voxel worlds in true room-scale VR. My immediate goal is a playable prototype that launches the original PC game straight into a full-view HMD, lets me move with smooth locomotion, and interact with the environment and the basic in-game tools just as I do on a monitor today.

Target platform is PCVR; if it runs through OpenVR/OpenXR it should automatically cover Rift, Vive, Index and most other desktop headsets, so please architect the mod with broad headset compatibility in mind.

The game runs on a custom engine, so you will likely need to reverse-engineer or inject at the rendering layer. I’m open to whatever approach—DLL hooks, OpenXR wrappers, or similar—gets us reliable head-tracked rendering and motion-tracked input without breaking the base game.

Prototype acceptance criteria
• Launch Teardown in VR from Steam and enter the first sandbox level
• Smooth locomotion via thumbsticks / touchpads, head-tracking fully 6DoF
• Grab, pick up, and throw in-game objects with motion controllers
• Use the standard sledgehammer, spray can, and extinguisher with natural hand poses
• Stable 90 FPS on a typical gaming PC (This doesn't have to hit 90 fps, just as long as the game is playable in a high enough frame rate).

Once this cornerstone build feels right, I’ll reopen the project for a second phase covering menus, custom UI, vehicle driving, and more advanced tool support, so clean, commented code and a modular architecture will be appreciated.

If you have experience porting flatscreen titles to VR, especially those on proprietary engines, I’d love to see your approach and a rough timeline for delivering the playable build.

•Price Is low cause this is phase one, just need the logic and getting the game to run in vr with the basic features, I'll be paying 400 once the demo version of the mod is fully working to satisfaction, after that phase two will start and we will begin by adding features like driving every vehicle in the game to using custom items and equipment and i'll be paying a lot more to get those added plus many more features.

Skills: C Programming, Game Design, C# Programming, Software Architecture, C++ Programming, Unity 3D, Reverse Engineering, Virtual Reality

Job Description:

I am looking for an experienced Blender add-on developer to complete and harden an advanced auto quad remeshing project built for Blender 4.2+ / 5.x. The core project is already in progress, with a Python add-on layer, a native engine layer, and a large roadmap already defined. The remaining work is to finish the missing pieces, fix integration gaps, and make the addon stable and reliable across Windows, macOS, and Linux.

The ideal developer should be comfortable working with Blender’s Python API, C++ integration, ctypes or native shared libraries, mesh processing, and cross-platform packaging. This project is not a basic UI plugin; it involves deep geometry processing, modular architecture, and release hardening for real-world use.

Work Scope:

Review the existing codebase and identify remaining gaps

Complete missing or incomplete addon features

Stabilize the Python-to-native engine bridge

Ensure the addon loads and runs correctly on Windows, macOS, and Linux

Fix compatibility issues across Blender versions where needed

Improve error handling, fallback behavior, and diagnostics

Verify build/package flow for installable addon ZIP release

Run and improve tests so the addon is reliable in production

Clean up any unfinished modules, stubs, or broken integration points


Required Skills:

Strong Python development experience

Strong C++ experience

Blender add-on development experience

Experience with mesh processing or geometry algorithms

Familiarity with cross-platform build and packaging

Ability to debug integration issues between Python and native code

Good understanding of production-quality software stability


Nice to Have:

Previous work on Blender remeshing, retopology, or modeling tools

Experience with OpenMP, Eigen, CHOLMOD, or similar numerical libraries

Experience shipping addons or plugins for multiple operating systems

Strong testing and debugging discipline


Expected Deliverables:

Completed and cleaned-up addon codebase

Fixed cross-platform compatibility

Stable addon release ZIP

Clear documentation for installation and usage

Any necessary build or packaging scripts

Testing and validation summary


Important: This project already has a strong foundation, so I am looking for someone who can work confidently in an existing codebase, understand the architecture quickly, and finish the remaining work properly rather than rewriting everything from scratch.

Please include:

Relevant Blender add-on work you have done

C++/Python projects you have shipped

Any cross-platform software you have supported

Your approach for debugging and stabilizing a partially completed codebase

Skills: PHP, Python, C++ Programming, Debugging, OpenGL, Software Development, Documentation, Blender

Hi,

I have two boards which I would like a PCB designer to implement. Files are currently on EasyEDA.

There are two designs for the controller now. Both designs are minor modifications from the original. Modifications are attached to this message.

1. PCB Controller with ESP32-C6 N8
2. PCB Controller with original ESP-32 + MGM

I would like the PCB designer to take into account RoHs standards.

Are you able to help with this product?

Regards,

Shane

We are seeking a skilled audio engineer to utilize Vocalign for aligning two audio files that are currently out of sync.
It is a 90 minute speech.

The ideal candidate will have experience in audio editing and be proficient in using Vocalign or similar software tools. Your task will involve importing the 2 audio files, adjusting their timings, and ensuring a seamless sync. Attention to detail and good communication skills are essential to understand our requirements clearly.

If you know how to use vocalign or similar software properly, you will know it should do it automatically.

I'm hiring one engineer to work alongside me on a synthetic data generation and computer vision pipeline using Unreal Engine 5. Fixed-price project with a hard early-June deadline.

Deliverables
Five milestones, each tied to a payment release. All work is delivered to a shared Git repo.

Milestone 1 — Setup & Dataset Spec (end of week 1)
Working local environment: UE5 project running, Python ML stack installed, GeoDeep operational
Written dataset format spec agreed with me (image format, label schema, geospatial metadata structure)
First end-to-end test: 200 synthetic frames captured → loaded into training pipeline → one training epoch completes successfully
Validation harness scaffolded (script that produces per-class AP on a held-out set)

Milestone 2 — UE5 Content Pipeline (end of week 2)
PCG graph for procedural placement along splines with parameterized density, orientation, spacing
Master material with parameterized variation states + at least 4 decal variants
Sequencer camera flythrough + Movie Render Queue configuration producing deterministic batch output
Editor Utility Widget that triggers a capture run against my C++ plugin APIs

Milestone 3 — First Trained Model (end of week 3)
YOLOv8/v11 model trained on initial synthetic dataset
Validation report: per-class AP on synthetic val split AND on real reference imagery I provide
Written analysis of failure modes and proposed domain randomization changes

Milestone 4 — Sim-to-Real Iteration (end of week 4)
Second training run incorporating randomization changes from M3 Updated validation report with before/after comparison
ONNX export of the best-performing model with documented input/output schema

Milestone 5 — Inference Loop & Handoff (end of week 5)
GeoDeep integration: ONNX model running on a real GeoTIFF I provide, producing georeferenced GeoJSON detections
End-to-end demo script that runs the full loop on command
Final documentation: README covering training procedure, dataset regeneration, inference invocation, known limitations
30-minute knowledge-transfer call

Week 5 is buffer for demo polish and bug fixes — included in the price, no additional milestones.

What's Explicitly Out of Scope

Custom C++ plugin development
Cesium for Unreal integration work (already exists)
Production deployment, MLOps, model serving infrastructure
Achieving any specific accuracy threshold — this is a research effort, deliverables are artifacts and methodology, not benchmark numbers

Must-Have Skills

Ultralytics YOLOv8/v11 end-to-end: training, augmentation, ONNX export
Demonstrable sim-to-real experience — you have trained a model on synthetic data and deployed it on real imagery
Geospatial Python libraries
UE5 editor fluency: Blueprints, PCG framework (5.4+), Sequencer, Movie Render Queue
Materials and decals in UE5
Editor Utility Widgets + Python in UE

Nice to Have

Drone or satellite imagery experience
NVIDIA Omniverse Replicator or Unity Perception background
Substrate Materials experience

To Apply, Please Answer

Link or describe one project where you trained a model on synthetic data and deployed it on real imagery. What broke first, and how did you diagnose it?

Walk me through how you'd structure a PCG graph in UE5 to place ~500 procedurally distributed objects along a spline with randomized density and orientation.

Confirm you can commit to a fixed early-June delivery and are comfortable with milestone-based payment.
Your fixed-price quote for the full scope above.

Generic AI-generated cover letters will be ignored. Answer the four questions directly and we'll talk.

Software Developer Needed to Build PDF Drawing Takeoff Tool for the exterior building cladding Projects.

Job Description

I am looking to develop a software tool that can generate material takeoffs directly from architectural PDF drawings.

The program should allow the user to upload architectural drawings (PDF) and automatically or semi-automatically extract quantities such as:

Wall areas (square feet)
Linear feet of trims
Openings (windows and doors)
Export results to Excel

The tool should include a PDF viewer where the user can set the drawing scale and verify the takeoff results.

Required Features
Upload architectural PDF drawings
Ability to set drawing scale
Detect or trace wall areas
Identify windows and doors
Calculate square footage and linear footage
Export takeoff results to Excel
Simple user interface

Required Skills

We are looking for someone experienced with:

PDF drawing processing
Computer vision / image recognition
Python or C++ development
Libraries such as OpenCV, TensorFlow, or PyTorch
CAD / drawing related workflows
Experience with construction estimating software is a big plus

Skills: Python, Excel, Software Development, OpenCV, Computer Vision, Automation, Software Engineering, Image Recognition

The Work:
Modifying and extending an existing Qt app.
Working with ARM Linux.
Device tree and driver-level work (V4L2 or similar camera/hardware drivers a plus).

The Skills:
Solid Qt/C++ experience.
Embedded Linux experience — especially ARM targets.

Comfortable working close to the hardware (device drivers, kernel interfaces).

This would be ongoing remote work, working with our small team. If you have relevant experience, please send me a message.

Thanks,

Skills: C Programming, Linux, Software Architecture, C++ Programming, Software Development, Qt, ARM, Embedded Systems

We are developing a companion Android application for a high-end, specialized outdoor/tactical IoT device. This app connects to our custom hardware via BLE/WiFi and acts as a remote control dashboard and live viewfinder. It streams real-time H.265 video, displays AI-driven data overlays, and manages complex environmental profiles and calculations.
​Note: Specific details about the hardware and product purpose will be shared during the interview phase after signing an NDA.
​Current Status:
We have the basic screen structures, feature requirements, and wireframe concepts defined. The app will consist of 6 core screens:
​Splash & Boot Sequence
​Pairing (BLE/WiFi Connection Management)
​Live View (Video Streaming + Real-time HUD Overlays + AI Data)
​Data Profiles (Managing complex physics and environmental variables)
​Calibration & Advanced Device Settings
​Gallery (Remote Media Browser)
​What We Need:
We are looking for an experienced UI/UX Designer to take our basic structures and turn them into a polished, production-ready app design. You will need to:
​Detail the UX Flow: Flesh out the detailed user journeys, edge cases, and micro-interactions based on our basic wireframes.
​High-Fidelity UI Design: Create a modern, premium, "Tactical HUD" or "Tech-heavy Dashboard" aesthetic. The design MUST be in a Dark Mode theme (e.g., deep charcoal/obsidian black with sharp accent colors). It should look robust, clean, and highly intuitive for outdoor field use.
​Developer Handoff: Prepare the final designs for our Android Native (Kotlin/C++) development team. You must provide a well-organized Figma file and exportable graphic assets (icons, buttons, transparent overlays, etc.) ready for implementation.
​Deliverables:
​A complete Figma project file with a clear design system (Typography, Colors, Components).
​High-fidelity mockups for all core screens and necessary sub-screens/pop-ups.
​A basic interactive prototype within Figma demonstrating screen transitions.
​All graphical assets sliced and exported for Android development.
​Ideal Candidate:
​Proven experience in mobile app UI/UX design (Android).
​Strong portfolio showcasing Dark Mode, dashboard-style, or tech-heavy interfaces. (Experience with tactical, sports, or drone/camera apps is a huge plus).
​Expert proficiency in Figma and developer handoff processes.
​Excellent communication skills to understand our specific technical constraints (e.g., leaving transparent areas for live video streams).
​To Apply:
Please submit your proposal along with a link to your portfolio. Highlight any past projects that feature dark themes, HUDs, or complex technical dashboards.

I'm looking for an experienced developer to integrate my [PC/mobile/web] game with Discord. The goal is to enhance player engagement by connecting in-game activity with Discord features.
Game Details
• Engine/Platform: [Unity/Unreal/Godot/custom engine — specify version]
• Language: [C#, C++, JavaScript, Python, etc.]
• Current Status: [In development / beta / released]
• Platform: [Steam/Itch.io/Standalone/Web/Mobile]
Integration Requirements
(Check the ones you need)
Priority Features:
• [ ] Discord Rich Presence — display game status, current level/score, party size
• [ ] Discord Bot — server commands for stats, leaderboards, player lookup
• [ ] Webhook Notifications — auto-post achievements, milestones to Discord channels
• [ ] Discord Game SDK — in-game overlay, invite friends, spectate support
• [ ] Discord Activities (Embedded App) — run mini-game inside Discord (requires web tech)
Nice-to-Have:
• [ ] OAuth2 login (sign in with Discord)
• [ ] Role syncing (link in-game ranks to Discord roles)
• [ ] Voice channel integration
Deliverables
• Clean, documented source code
• Setup instructions for my server/environment
• Basic testing & bug fixes included
• (Optional) 30-day support period post-delivery
Budget & Timeline
• Budget: $[your range — e.g., 500–2,000]
• Timeline: [e.g., 2–4 weeks]
• Payment: Milestone-based (e.g., 30% upfront, 40% mid-project, 30% on delivery)
Required Skills
• Discord API / Discord Game SDK experience
• [Your game engine] development experience
• REST API & webhook implementation
• Git/version control
How to Apply
Please include:
1. Links to past Discord integrations or game projects
2. Which features above you've implemented before
3. Your proposed approach/tech stack for this project
4. Your availability and estimated completion date
----
Pro tip: Post this on Upwork with "Discord bot" + "Unity" (or your engine) as keywords. On Fiverr, search for "Discord bot developer" and message sellers directly with this brief.
Want me to tailor this for a specific integration type or budget?

Skills: JavaScript, C# Programming, C++ Programming, Unity 3D, Game Development, Unity, REST API, Discord API